assay-minitest 0.1.0

data/.ruby

@@ -0,0 +1,52 @@
+---
+source:
+- meta
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+copyrights:
+- holder: Thomas Sawyer
+  year: '2012'
+  license: BSD-2-Clause
+replacements: []
+alternatives: []
+requirements:
+- name: assay
+- name: detroit
+  groups:
+  - build
+  development: true
+- name: qed
+  groups:
+  - test
+  development: true
+dependencies: []
+conflicts: []
+repositories:
+- uri: git@github.com:rubyworks/assay-minitest.git
+  scm: git
+  name: upstream
+resources:
+  home: http://rubyworks.github.com/assay-minitest
+  docs: http://rubydoc.info/gems/assay-minitest
+  code: http://github.com/rubyworks/assay-minitest
+  mail: http://groups.google.com/groups/rubyworks-mailinglist
+extra: {}
+load_path:
+- lib
+revision: 0
+created: '2012-01-18'
+summary: MiniTest on Assay
+title: Assay MiniTest
+version: 0.1.0
+name: assay-minitest
+description: ! 'Assay MiniTest defines a set of MiniTest-compatible assertion and
+  extension
+
+  method which seemlessly delegate on Assay assertions. This allows developers
+
+  to change test frameworks without having to completely rewrite a slew of
+
+  previously written MiniTest-based tests and/or sepcifications.'
+organization: Rubyworks
+date: '2012-01-26'

data/COPYING.rdoc

@@ -0,0 +1,39 @@
+= COPYRIGHT
+
+== NOTICES
+
+=== Assay MiniTest
+
+Copyright:: (c) 2012 RubyWorks
+License::   (r) BSD-2-Clause
+Website::   http://rubyworks.github.com/assay-minitest
+
+
+== LICENSES
+
+=== BSD-2-Clause License
+
+    Assay MiniTest
+
+    Copyright (c) 2012 Rubyworks. All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+       1. Redistributions of source code must retain the above copyright notice,
+          this list of conditions and the following disclaimer.
+
+       2. Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+    OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+    EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/HISTORY.rdoc

@@ -0,0 +1,12 @@
+= HISTORY
+
+== 0.1.0 | 2012-01-26
+
+This is the initial release of Assay MiniTest. Compatibility
+with MiniTest's assertion and expectation methods is nearly
+complete.
+
+Changes:
+
+* Happy Birthday!
+

data/README.rdoc

@@ -0,0 +1,75 @@
+= Assay MiniTest
+
+{Homepage}[http://rubyworks.github.com/assay-minitest] /
+{Source Code}[http://github.com/rubyworks/assay-minitest] /
+{MailingList}[http://groups.google.com/group/rubyworks-mailinglist]
+
+
+== DESCRIPTION
+
+Assay MiniTest is a compatability layer for using MiniTest's test or spec
+assertion notations with the {Assay}[http://rubyworks.github.com/assay]
+assertions framework.
+
+Assay MiniTest defines a set of MiniTest-compatible assertion methods
+which depend on Assay's assertion classes. This allows developers to
+change test frameworks without having to change a slew of previously
+defined assertions calls.
+
+Assay defines assertions in the same way that Ruby defines exceptions.
+An assertion is nothing more that an extended Exception class.
+Assay provides a complete set of these assertion classes for all
+common assertion needs. See {Assay}[http://rubyworks.github.com/assay]
+project for more information on this foundational library.
+
+
+== SYNOPSIS
+
+Simply require the `assay/minitest` script, and include the `Assay::Matchers`
+mixin module into your tests wherever your test framework requires it (which 
+may be as simple as the toplevel namespace).
+
+  require 'assay/minitest'
+
+  include Assay::Assertions
+
+Now assertions can be made just as if you were using MiniTest.
+
+  assert_equal(10, 5+5)
+
+  refute_kind_of(String, 10)
+
+Alternately, you can use MiniTest's expectations notation.
+
+  include Assay::Extensions
+
+  (5+5).must_equal(10)
+
+  10.must_be_kind_of?(Fixnum)
+
+
+== LIMITATIONS
+
+Note that compatibility is not 100%, yet, though it is fairly close.
+Compatibilty will improve with future releases. Please feel _obligated_
+to submit a patch, if you need a missing a feature ;)
+
+
+== INSTALLATION
+
+To install with RubyGems simply open a console and type:
+
+  $ gem install assay-minitest
+
+Site installation with the tarball can be done with Ruby Setup
+(gem install setup). See http://rubyworks.github.com/setup.
+
+
+== COPYRIGHTS
+
+Copyright (c) 2012 Rubyworks
+
+This program is ditributed under the terms of the *BSD-2-Clause* license.
+
+See LICENSE.rdoc file for details.
+

data/lib/assay-minitest.rb

@@ -0,0 +1,18 @@
+require 'assay'
+
+require_relative 'assay-minitest/assertions'
+require_relative 'assay-minitest/extensions'
+
+module Assay::Assertions
+  include Assay::MiniTest::Assertions
+end
+
+module Assay::Extensions
+  include Assay::MiniTest::Extensions
+end
+
+class Object
+  # should we be doing this here?
+  include Assay::Extensions
+end
+

data/lib/assay-minitest.yml

@@ -0,0 +1,52 @@
+---
+source:
+- meta
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+copyrights:
+- holder: Thomas Sawyer
+  year: '2012'
+  license: BSD-2-Clause
+replacements: []
+alternatives: []
+requirements:
+- name: assay
+- name: detroit
+  groups:
+  - build
+  development: true
+- name: qed
+  groups:
+  - test
+  development: true
+dependencies: []
+conflicts: []
+repositories:
+- uri: git@github.com:rubyworks/assay-minitest.git
+  scm: git
+  name: upstream
+resources:
+  home: http://rubyworks.github.com/assay-minitest
+  docs: http://rubydoc.info/gems/assay-minitest
+  code: http://github.com/rubyworks/assay-minitest
+  mail: http://groups.google.com/groups/rubyworks-mailinglist
+extra: {}
+load_path:
+- lib
+revision: 0
+created: '2012-01-18'
+summary: MiniTest on Assay
+title: Assay MiniTest
+version: 0.1.0
+name: assay-minitest
+description: ! 'Assay MiniTest defines a set of MiniTest-compatible assertion and
+  extension
+
+  method which seemlessly delegate on Assay assertions. This allows developers
+
+  to change test frameworks without having to completely rewrite a slew of
+
+  previously written MiniTest-based tests and/or sepcifications.'
+organization: Rubyworks
+date: '2012-01-26'

data/lib/assay-minitest/assertions.rb

@@ -0,0 +1,495 @@
+module Assay; end
+module Assay::MiniTest
+
+  # This module holds the MiniTest assertion methods for MiniTest
+  # compatibility.
+  #
+  # While it does not provide 100% of MiniTest's assertions at the moment,
+  # compatibility is very close and will improved with upcoming releases.
+  #
+  # TODO: Should we adjust error messages to be like MiniTests ?
+  #
+  module Assertions
+
+    #
+    def assert(truth, msg=nil)
+      Assertion.assert!(truth, :message=>msg)
+    end
+
+    #
+    def refute(untruth, msg=nil)
+      Assertion.refute!(untruth, :message=>msg)
+    end
+
+    #
+    #def assert_alias_method(object, alias_name, original_name, message = nil)
+    #end
+
+    #
+    # Passes if actual is like expected, where `like` means satisfyin any one 
+    # of `#===`, `#==`, `#eql?` or `#equal?` calls.
+    #
+    # This is not strictly a Test::Unit assertion but is added here to cover
+    # all of Assay's availabe assertion classes.
+    #
+    def assert_alike(exp, act, msg=nil)
+      LikeAssay.assert!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if actual is NOT like expected, where `like` means satisfyin any
+    # one of `#===`, `#==`, `#eql?` or `#equal?` calls.
+    #
+    def refute_alike(exp, act, msg=nil)
+      LikeAssay.refute!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    #
+    #
+    def assert_block(message="assert_block failed.", &block)
+      ExecutionAssay.assert!(:message=>message, &block)
+    end
+
+    #
+    # Passes if `boolean` is either `true` or `false`.
+    #
+    def assert_boolean(boolean, message=nil)
+      BooleanAssay.assert!(boolean, :message=>message)
+    end
+
+    #
+    # Passes if `boolean` is neither `true` or `false`.
+    #
+    def refute_boolean(boolean, message=nil)
+      BooleanAssay.refute!(boolean, :message=>message)
+    end
+
+    #
+    #def assert_const_defined(object, constant_name, message = nil)
+    #end
+    #
+    #def refute_const_defined(object, constant_name, message = nil)
+    #end
+
+    # Passes if object is empty.
+    #
+    #   assert_empty(object)
+    #
+    def assert_empty(exp, msg=nil)
+      EmptyAssay.assert!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if object is not empty.
+    #
+    #   refute_empty(object)
+    #
+    def refute_empty(exp, msg=nil)
+      EmptyAssay.refute!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if expected == +actual.
+    #
+    # Note that the ordering of arguments is important,
+    # since a helpful error message is generated when this
+    # one fails that tells you the values of expected and actual.
+    #
+    #   assert_equal 'MY STRING', 'my string'.upcase
+    #
+    def assert_equal(exp, act, msg=nil)
+      EqualAssay.assert!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if expected != actual
+    #
+    #  refute_equal 'some string', 5
+    #
+    def refute_equal(exp, act, msg=nil)
+       EqualAssay.refute!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    #def assert_fail_assertion(message = nil) 
+    #end
+
+    #
+    # Passed if object is +false+.
+    #
+    #   assert_false(false)
+    #
+    def assert_false(exp, msg=nil)
+      FalseAssay.assert!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passed if object is not +false+.
+    #
+    #   refute_false(false)
+    #
+    def refute_false(exp, msg=nil)
+      FalseAssay.refute!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if expected and actual are equal within delta tolerance.
+    #
+    #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
+    #
+    def assert_in_delta(exp, act, delta, msg=nil)
+      WithinAssay.assert!(act, exp, delta, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if expected and actual are equal not within delta tolerance.
+    #
+    #   refute_in_delta 0.05, (50000.0 / 10**6), 0.00001
+    #
+    def refute_in_delta(exp, act, delta, msg=nil)
+      WithinAssay.refute!(act, exp, delta, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if `expected_float` and `actual_float` are within `epsilon`.
+    #
+    def assert_in_epsilon(exp, act, epsilon=0.001, message=nil) 
+      delta = [exp, act].min * epsilon
+      WithinAssay.assert!(act, exp, delta, :message=>message, :backtrace=>caller)
+    end
+
+    #
+    # Passes if `expected_float` and `actual_float` are NOT within `epsilon`.
+    #
+    def refute_in_epsilon(exp, act, epsilon=0.001, message=nil)
+      delta = [exp, act].min * epsilon
+      WithinAssay.refute!(act, exp, delta, :message=>message, :backtrace=>caller)
+    end
+
+    #
+    # Passes if `collection` contains `member`.
+    #
+    def assert_includes(collection, member, message=nil) 
+      IncludeAssay.assert!(collection, member, :message=>message, :backtrace=>caller)
+    end
+
+    #
+    # Passes if `collection` does not contain `member`.
+    #
+    def refute_includes(collection, member, message=nil)
+      IncludeAssay.refute!(collection, member, :message=>message, :backtrace=>caller) 
+    end
+
+    #
+    # Passes if object is an instance of class.
+    #
+    #   assert_instance_of(String, 'foo')
+    #
+    def assert_instance_of(cls, obj, msg=nil)
+      InstanceAssay.assert!(obj, cls, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object is not an instance of class.
+    #
+    #   refute_instance_of(String, 500)
+    #
+    def refute_instance_of(cls, obj, msg=nil)
+      InstanceAssay.refute!(obj, cls, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object .kind_of? klass
+    #
+    #   assert_kind_of(Object, 'foo')
+    #
+    def assert_kind_of(cls, obj, msg=nil)
+      KindAssay.assert!(obj, cls, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object .kind_of? klass
+    #
+    #   refute_kind_of(Object, 'foo')
+    #
+    def refute_kind_of(cls, obj, msg=nil)
+      KindAssay.refute!(obj, cls, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object matches pattern using `#=~` method.
+    #
+    #   assert_match(/\d+/, 'five, 6, seven')
+    #
+    def assert_match(pattern, string, msg=nil)
+      MatchAssay.assert!(string, pattern, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object does not match pattern using `#=~` method.
+    #
+    #   assert_no_match(/two/, 'one 2 three')
+    #
+    def refute_match(pattern, string, msg=nil)
+      MatchAssay.refute!(string, pattern, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object does not match pattern using `#!~` method.
+    #
+    #   assert_no_match(/two/, 'one 2 three')
+    #
+    def assert_no_match(pattern, string, msg=nil)
+      NoMatchAssay.assert!(string, pattern, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object is +nil+.
+    #
+    #   assert_nil(nil)
+    #
+    def assert_nil(exp, msg=nil)
+      NilAssay.assert!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object is not +nil+.
+    #
+    #   refute_nil(true)
+    #
+    def refute_nil(exp, msg=nil)
+      NilAssay.refute!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    # 
+    # Passes if a block outputs matching test to `stdout` or `staderr`.
+    #
+    # This does not work _exactly_ like the original MiniTest assertion in
+    # that it is an *and* condition between the two stdout and stderr, whereas
+    # the original is and *or* condition.
+    #
+    # Note that this assertion translates into two separate underlying assertions,
+    # so counts for it may be double of what one might expect.
+    #
+    def assert_output(stdout=nil, stderr=nil, &block)
+      StdoutAssay.assert!(stdout, :backtrace=>caller, &block) if stdout
+      StderrAssay.assert!(stderr, :backtrace=>caller, &block) if stderr
+    end
+
+    #
+    # Passes if a block outputs matching test to `stdout` or `staderr`.
+    #
+    # This does not work _exactly_ like the original MiniTest assertion in
+    # that it is an *and* condition between the two stdout and stderr, whereas
+    # the original is and *or* condition.
+    #
+    # Note that this assertion translates into two separate underlying assertions,
+    # so counts for it may be double of what one might expect.
+    #
+    def refute_output(stdout=nil, stderr=nil, &block)
+      StdoutAssay.refute!(stdout, :backtrace=>caller, &block) if stdout
+      StderrAssay.refute!(stderr, :backtrace=>caller, &block) if stderr
+    end
+
+    #
+    # Like {#assert_output} but ensures no output.
+    #
+    def assert_silent(msg=nil, &block)
+      SilentAssay.assert!(:message=>msg, :backtrace=>caller, &block)
+    end
+
+    #
+    # Like {#refute_output} but ensures some output.
+    #
+    def refute_silent(msg=nil, &block)
+      SilentAssay.refute!(:message=>msg, :backtrace=>caller, &block)
+    end
+
+    #
+    # Passes it +predicate+ sent to object returns postively.
+    #
+    #   assert_predicate(10, :even?)
+    #
+    def assert_predicate(object, predicate, message=nil) 
+      ExecutionAssay.assert!(:message=>message, :backtrace=>caller) do
+        object.__send__(predicate)
+      end
+    end
+
+    #
+    # Passes it +predicate+ sent to object returns negatively.
+    #
+    #   refute_predicate(10, :odd?)
+    #
+    def refute_predicate(object, predicate, message=nil) 
+      ExecutionAssay.refute!(:message=>message, :backtrace=>caller) do
+        object.__send__(predicate)
+      end
+    end
+
+    #
+    # Passes if +object+ respond_to? +methods+.
+    #
+    #   assert_respond_to 'bugbear', :slice
+    #
+    def assert_respond_to(reciever, method, msg=nil)
+      RespondAssay.assert!(reciever, method, :message=>msg, :backtrace=>caller)
+    end
+    alias_method :assert_responds_to, :assert_respond_to
+
+    #
+    # Passes if +object+ does not respond_to? +methods+.
+    #
+    #   refute_respond_to 'bugbear', :slice
+    #
+    def refute_respond_to(reciever, method, msg=nil)
+      RespondAssay.refute!(reciever, method, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if +expected+ .eql? +actual+.
+    #
+    # Note that the ordering of arguments is important,
+    # since a helpful error message is generated when this
+    # one fails that tells you the values of expected and actual.
+    #
+    #   assert_equivalent 'MY STRING', 'my string'.upcase
+    #
+    def assert_equivalent(exp, act, msg=nil)
+      EqualityAssay.assert!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if +criterion+ is NOT equivalent to +actual+ as tested using `#eql?`.
+    #
+    #  refute_equivalent 'some string', 5
+    #
+    def refute_equivalent(criterion, act, msg=nil)
+      EqualityAssay.refute!(act, criterion, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    #
+    #
+    def assert_operator(receiver, operator, operand, message=nil) 
+      ExecutionAssay.assert!(:message=>message, :backtrace=>caller) do
+        receiver.__send__(operator, operand)
+      end
+    end
+
+    #
+    #
+    #
+    def refute_operator(receiver, operator, operand, message=nil) 
+      ExecutionAssay.refute!(:message=>message, :backtrace=>caller) do
+        receiver.__send__(operator, operand)
+      end
+    end
+
+    #
+    # Passes if the block raises given exception(s).
+    #
+    #   assert_raises RuntimeError do
+    #     raise 'Boom!!!'
+    #   end
+    #
+    def assert_raises(*exceptions, &block)
+      msg = (Exception === exceptions.last ? exceptions.pop : nil)
+      RaiseAssay.assert!(*exceptions, :message=>msg, :backtrace=>caller, &block)
+    end
+
+    #
+    # Passes if the block *does not* raise given exception(s).
+    #
+    #   refute_raises RuntimeError do
+    #     raise 'Boom!!!'
+    #   end
+    #
+    def refute_raises(*exceptions, &block)
+      msg = (Exception === exceptions.last ? exceptions.pop : nil)
+      RaiseAssay.refute!(*exceptions, :message=>msg, :backtrace=>caller, &block)
+    end
+
+    #
+    # Passes if the block yields successfully.
+    #
+    #   refute_nothing_raised "Couldn't do the thing" do
+    #     do_the_thing
+    #   end
+    #
+    def assert_nothing_raised(msg=nil, &block)
+      RescueAssay.refute!(Exception, :message=>msg, :backtrace=>caller, &block)
+    end
+
+    #
+    # Passes if the block yields successfully.
+    #
+    #   refute_nothing_raised "Couldn't do the thing" do
+    #     do_the_thing
+    #   end
+    #
+    def refute_nothing_raised(msg=nil, &block)
+      RescueAssay.assert!(Exception, :message=>msg, :backtrace=>caller, &block)
+    end
+
+    #
+    # Passes if actual is the same exact object as expected.
+    #
+    #   assert_same(object, object)
+    #
+    def assert_same(exp, act, msg=nil)
+      IdentityAssay.assert!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if actual is not the same exact object as expected.
+    #
+    #   refute_same(object, other)
+    #
+    def refute_same(exp, act, msg=nil)
+      IdentityAssay.refute!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    #def assert_send(send_array, message=nil)
+    #end
+
+    #
+    # Passes if the block throws `expected` object.
+    #
+    #   assert_throw :done do
+    #     throw :done
+    #   end
+    #
+    def assert_throws(expected, msg=nil, &blk)
+      ThrowAssay.assert!(expected, :message=>msg, :backtrace=>caller, &blk)
+    end
+
+    #
+    # Passes if the block does not throws `expected` object.
+    #
+    #   refute_throws :done do
+    #     throw :chimp
+    #   end
+    #
+    def refute_throws(expected, msg=nil, &blk)
+      ThrowAssay.refute!(expected, :message=>msg, :backtrace=>caller, &blk)
+    end
+
+    #
+    # Passed if object is +true+.
+    #
+    def assert_true(exp, msg=nil)
+      TrueAssay.assert!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passed if object is not +true+.
+    #
+    #   refute_true(false)
+    #
+    def refute_true(exp, msg=nil)
+      TrueAssay.refute!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+  end
+
+end