assay-minitest 0.1.0

data/lib/assay/minitest.rb

@@ -0,0 +1 @@
+require 'assay-minitest'

data/spec/01_minitest_extensions.rdoc

@@ -0,0 +1,217 @@
+= MiniTest Compatible Extensions
+
+  require 'assay/minitest'
+
+  class ::Object
+    include ::Assay::Extensions
+  end
+
+== must_be
+
+  1.must_be(:<, 2)
+  1.must_be(:odd?)
+
+  expect ::ExecutionAssay do
+    1.wont_be(:<, 2)
+  end
+
+  1.wont_be(:>, 2)
+  1.wont_be(:even?)
+
+== must_equal
+
+  1.must_equal(1)
+
+  expect ::EqualAssay do
+    1.must_equal(2)
+  end
+
+  1.wont_equal(2)
+
+== TrueAssay
+
+  true.must_be_true
+
+  expect ::TrueAssay do
+    false.must_be_true
+  end
+
+  false.wont_be_true
+
+== must_be_false
+
+  false.must_be_false
+
+  expect ::FalseAssay do
+    true.must_be_false
+  end
+
+  true.wont_be_false
+
+== must_be_nil
+
+  nil.must_be_nil
+
+  expect ::NilAssay do
+    true.must_be_nil
+  end
+
+  false.wont_be_nil
+
+== must_be_empty
+
+  [].must_be_empty
+
+  expect ::EmptyAssay do
+    [1].must_be_empty
+  end
+
+  [1].wont_be_empty
+
+== must_include
+
+  [1].must_include(1)
+
+  expect ::IncludeAssay do
+    [1].must_include(2)
+  end
+
+  [1].wont_include(2)
+
+== must_be_within_delta
+
+  1.must_be_within_delta(2, 1.5)
+
+  expect ::WithinAssay do
+    1.must_be_within_delta(2, 0.5)
+  end
+
+  1.wont_be_within_delta(2, 0.5)
+
+== must_match
+
+  "abc".must_match(/a/)
+
+  expect ::MatchAssay do
+    "abc".must_match(/x/)
+  end
+
+  "abc".wont_match(/g/)
+
+== must_eql
+
+  1.must_eql(1)
+
+  expect ::EqualityAssay do
+    1.must_eql(1.0)
+  end
+
+  1.wont_eql(1.0)
+
+== must_be_same_as
+
+  :a.must_be_same_as(:a)
+
+  expect ::IdentityAssay do
+    "a".must_be_same_as("a")
+  end
+
+  :a.wont_be_same_as('a')
+
+== must_be_instance_of
+
+  1.must_be_instance_of(Fixnum)
+
+  expect ::InstanceAssay do
+    1.must_be_instance_of(String)
+  end
+
+  1.wont_be_instance_of(String)
+
+== must_kind_of
+
+  1.must_be_kind_of(Integer)
+
+  expect ::KindAssay do
+    1.must_be_kind_of(String)
+  end
+
+  1.wont_be_kind_of(String)
+
+== must_raise
+
+  procedure = lambda{ raise ::ArgumentError }
+
+  procedure.must_raise(::ArgumentError)
+
+  expect ::RaiseAssay do
+    procedure.must_raise(::TypeError)
+  end
+
+  procedure.wont_raise(::TypeError)
+
+== must_respond_to
+
+  "string".must_respond_to(:upcase)
+
+  expect ::RespondAssay do
+    "string".must_respond_to(:not_a_method)
+  end
+
+  "string".wont_respond_to(:not_a_method)
+
+== must_satisfy
+
+  5.must_satisfy{ |x| x > 3 }
+
+  expect ::ExecutionAssay do
+    5.must_satisfy{ |x| x < 3 }
+  end
+
+  5.wont_satisfy{ |x| x < 3 }
+
+== must_send
+
+  5.must_send([:+, 1])
+
+  expect ::ExecutionAssay do
+    5.must_send([:upcase])
+  end
+
+  5.wont_send([:upcase])
+
+== must_throw
+
+  procedure = lambda{ throw :foo }
+
+  procedure.must_throw(:foo)
+
+  expect ::ThrowAssay do
+    procedure.must_throw(:bar)
+  end
+
+  procedure.wont_throw(:bar)
+
+== must_output
+
+  procedure = lambda{ puts "fun!" }
+
+  procedure.must_output('fun!')
+
+  expect ::OutputAssay do
+    procedure.must_output('not!')
+  end
+
+== must_be_like
+
+The `#must_be_like` method is not a MiniText expectation, but we have thrown it
+in for gooe measure.
+
+  /a/.must_be_like('a')
+
+  expect ::LikeAssay do
+    'a'.must_be_like(10)
+  end
+
+  'a'.wont_be_like(10)
+

data/spec/02_minitest_assertions.rdoc

@@ -0,0 +1,250 @@
+= Assertion Methods
+
+  require 'assay/minitest'
+
+  include ::Assay::Assertions
+
+== assert
+
+  assert(true, "yep it is so")
+
+  expect ::Assertion do
+    assert(false, "yep it is so")
+  end
+
+  refute(false, "not on you life")
+
+== assert_boolean
+
+  assert_boolean(true)
+  assert_boolean(false)
+
+  refute_boolean(nil)
+  refute_boolean(:foo)
+
+== assert_equal
+
+  assert_equal(1,1)
+
+  expect ::EqualAssay do
+    assert_equal(1,2)
+  end
+
+  refute_equal(1,2)
+
+== assert_true
+
+  assert_true(true)
+
+  expect ::TrueAssay do
+    assert_true(false)
+  end
+
+  refute_true(false)
+
+== assert_false
+
+  assert_false(false)
+
+  expect ::FalseAssay do
+    assert_false(true)
+  end
+
+  refute_false(true)
+
+== assert_nil
+
+  assert_nil(nil)
+
+  expect ::NilAssay do
+    assert_nil(true)
+  end
+
+  refute_nil(true)
+  refute_nil(false)
+
+== assert_in_delta
+
+  assert_in_delta(1, 1.5, 0.5)
+
+  expect ::WithinAssay do
+    assert_in_delta(1, 2.5, 1)
+  end
+
+  refute_in_delta(1, 2.5, 1)
+
+== assert_in_epsilon
+
+  assert_in_epsilon(1, 1.5, 2)
+
+  expect ::WithinAssay do
+    assert_in_epsilon(1, 2.5, 1)
+  end
+
+  refute_in_epsilon(1, 2.5, 1)
+
+== assert_match
+
+  assert_match(/a/, "abc")
+
+  expect ::MatchAssay do
+    assert_match(/x/, "abc")
+  end
+
+  refute_match(/a/, "bcd")
+
+== assert_no_match
+
+  assert_no_match(/a/, "bcd")
+
+  expect ::MatchAssay do
+    assert_no_match(/a/, "abc")
+  end
+
+== assert_operator
+
+  assert_operator(3, :<, 4)
+
+  expect ::ExecutionAssay do
+    assert_operator(4, :<, 3)
+  end
+
+  refute_operator(4, :<, 3)
+
+== assert_equivalent
+
+  assert_equivalent(1, 1)
+
+  expect ::EqualityAssay do
+    assert_equivalent(1, 1.0)
+  end
+
+  refute_equivalent(1, 1.0)
+
+== assert_empty
+
+  assert_empty([])
+
+  expect ::EmptyAssay do
+    assert_empty([1,2,3])
+  end
+
+  refute_empty([1,2,3])
+
+== assert_include
+
+  assert_includes([1,2,3], 1)
+
+  expect ::IncludeAssay do
+    assert_includes([1,2,3], 4)
+  end
+
+  refute_includes([1,2,3], 4)
+
+== assert_same
+
+  assert_same(:a, :a)
+
+  expect ::IdentityAssay do
+    assert_same("a", "a")
+  end
+
+  refute_same(:a, :b)
+
+== assert_instance_of
+
+  assert_instance_of(Fixnum, 1)
+
+  expect ::InstanceAssay do
+    assert_instance_of(String, 1)
+  end
+
+  refute_instance_of(String, 1)
+
+== assert_kind_of
+
+  assert_kind_of(Integer, 1)
+
+  expect ::KindAssay do
+    assert_kind_of(String, 1)
+  end
+
+  refute_kind_of(String, 1)
+
+== assert_raises
+
+  assert_raises(ArgumentError){ raise ArgumentError }
+
+  expect ::RaiseAssay do
+    assert_raises(ArgumentError){ raise TypeError }
+  end
+
+  refute_raises(ArgumentError){ raise TypeError }
+
+== assert_nothing_raised
+
+  assert_nothing_raised{ 'good' }
+
+  expect ::RescueAssay do
+    assert_nothing_raised{ raise }
+  end
+
+  refute_nothing_raised{ raise }
+
+== assert_respond_to
+
+  assert_respond_to("string", :upcase)
+
+  expect ::RespondAssay do
+    assert_respond_to("string", :not_a_method)
+  end
+
+  refute_respond_to("string", :not_a_method)
+
+== assert_block
+
+  assert_block{ :ok }
+
+  expect ::ExecutionAssay do
+    assert_block{ raise }
+  end
+
+== assert_throws
+
+  assert_throws(:foo){ throw :foo }
+
+  expect ::ThrowAssay do
+    assert_throws(:foo){ throw :bar }
+  end
+
+  refute_throws(:foo){ throw :bar }
+
+== assert_predicate
+
+  assert_predicate(10, :even?)
+
+  refute_predicate(10, :odd?)
+
+== assert_output
+
+  assert_output('this'){ puts 'this' }
+
+  refute_output('this'){ puts 'that' }
+
+== assert_silent
+
+  assert_silent{ nil }
+
+  refute_silent{ puts 'that' }
+
+== assert_alike
+
+  assert_alike(1,1)
+  assert_alike(1,1.0)
+
+  expect ::LikeAssay do
+    assert_alike(1,"1")
+  end
+
+  refute_alike(1,"1")
+