jeremymcanally-matchy 0.0.1

data/test/test_enumerable_expectations.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestEnumerableExpectations < Test::Unit::TestCase
+  def test_include
+    [1,2,3,4].should include(4)
+  end
+  
+  def test_include_fail
+    lambda {
+      [1,2,3,4].should include(6)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_exclude
+    [1,2,3,4].should exclude(9)
+  end
+  
+  def test_exclude_fail
+    lambda {
+      [1,2,3,4].should exclude(4)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_multi_include
+    [1,2,3,4].should include(1,2)
+  end
+  
+  def test_multi_include_fail
+    lambda {
+      [1,2,3,4].should include(6,7,8)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_multi_exclude
+    [1,2,3,4].should exclude(13,14)
+  end
+  
+  def test_multi_exclude_fail
+    lambda {
+      [1,2,3,4].should exclude(2,3,4)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_include
+    [1,2,3,4].should_not include(9)
+  end
+  
+  def test_negative_include_fail
+    lambda {
+      [1,2,3,4].should_not include(4)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_exclude
+    [1,2,3,4].should_not exclude(3)
+  end
+  
+  def test_negative_exclude_fail
+    lambda {
+      [1,2,3,4].should_not exclude(6,7)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_include_fail_message
+    obj = include(1)
+    obj.matches?([4,5,6])
+    
+    obj.failure_message.should be "Expected [4, 5, 6] to include [1]."
+  end
+  
+  def test_include_negative_fail_message
+    obj = include(1)
+    obj.matches?([4,5,6])
+    
+    obj.negative_failure_message.should be "Expected [4, 5, 6] to not include [1]."
+  end
+  
+  def test_exclude_fail_message
+    obj = exclude(4)
+    obj.matches?([4,5,6])
+    
+    obj.failure_message.should be "Expected [4, 5, 6] to exclude [4]."
+  end
+  
+  def test_exclude_negative_fail_message
+    obj = exclude(4)
+    obj.matches?([4,5,6])
+    
+    obj.negative_failure_message.should be "Expected [4, 5, 6] to not exclude [4]."
+  end
+end

data/test/test_error_expectations.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestErrorExpectations < Test::Unit::TestCase
+  def test_raises_error
+    lambda { raise "FAIL" }.should raise_error
+  end
+  
+  def test_raises_error_fail
+    lambda {
+      lambda { "WIN" }.should raise_error
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_raises_error
+    lambda { "WIN" }.should_not raise_error
+  end
+  
+  def test_negative_raises_error_fail
+    lambda {
+      lambda { raise "FAIL" }.should_not raise_error
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_raises_specific_error
+    lambda { raise TypeError }.should raise_error(TypeError)
+  end
+  
+  def test_raises_specific_error_fail_with_no_error
+    lambda {
+      lambda { "WIN" }.should raise_error(TypeError)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_raises_specific_error_fail_with_different_error
+    lambda {
+      lambda { raise StandardError }.should raise_error(TypeError)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_throws_symbol
+    lambda {
+      throw :win
+    }.should throw_symbol(:win)
+  end
+  
+  def test_throws_symbol_fails_with_different_symbol
+    lambda {
+      lambda {
+        throw :fail
+      }.should throw_symbol(:win)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_throws_symbol
+    lambda {
+      "not this time!"
+    }.should_not throw_symbol(:win)
+  end
+  
+  def test_negative_throws_symbol_fails_with_different_symbol
+    lambda{
+      lambda {
+        throw :fail
+      }.should_not throw_symbol(:fail)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_error_fail_message
+    obj = raise_error(TypeError)
+    obj.matches?(lambda { raise NameError })
+    
+    obj.failure_message.should =~ /Expected #<(.*)> to raise TypeError, but NameError was raised instead./
+  end
+  
+  def test_error_fail_message_when_no_error
+    obj = raise_error(TypeError)
+    obj.matches?(lambda { "moop" })
+    
+    obj.failure_message.should =~ /Expected #<(.*)> to raise TypeError, but none was raised./
+  end
+  
+  def test_error_negative_fail_message
+    obj = raise_error(TypeError)
+    obj.matches?(lambda { raise TypeError })
+    
+    obj.negative_failure_message.should =~ /Expected #<(.*)> to not raise TypeError./
+  end
+  
+  def test_throw_fail_message
+    obj = throw_symbol(:fail)
+    obj.matches?(lambda { throw :lame })
+    
+    obj.failure_message.should =~ /Expected #<(.*)> to throw :fail, but :lame was thrown instead./
+  end
+  
+  def test_throw_fail_message_when_no_symbol
+    obj = throw_symbol(:fail)
+    obj.matches?(lambda { "moop" })
+    
+    obj.failure_message.should =~ /Expected #<(.*)> to throw :fail, but no symbol was thrown./
+  end
+  
+  def test_throw_negative_fail_message
+    obj = throw_symbol(:fail)
+    obj.matches?(lambda { throw :fail })
+    
+    obj.negative_failure_message.should =~ /Expected #<(.*)> to not throw :fail./
+  end
+end

data/test/test_expectation_base.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestExpectationBase < Test::Unit::TestCase
+  def setup
+    @instance = Matchy::Expectations::Base.new(true, self)
+  end
+  
+  def test_ivars
+    @instance.instance_variable_get("@expected").should eql(true)
+  end
+  
+  def test_matches_throws_error
+    lambda {
+      @instance.matches?(true)
+    }.should raise_error
+  end
+  
+  def test_fail_should_raise
+    lambda {
+      @instance.fail!(false)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_pass
+    @instance.pass!(true)
+  end
+  
+  def test_failure_message
+    @instance.failure_message.should eql("OMG FAIL.")
+  end
+  
+  def test_negative_failure_message
+    @instance.negative_failure_message.should eql("OMG FAIL TO FAIL.")
+  end
+end

data/test/test_modals.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestModals < Test::Unit::TestCase
+  def setup
+    @expectation = Matchy::Expectations::EqlExpectation.new(3, self)
+    @bad_expectation = Matchy::Expectations::EqlExpectation.new(4, self)
+  end
+  
+  def test_should
+    3.should(@expectation)
+  end
+  
+  def test_should_not
+    3.should_not(@bad_expectation)
+  end
+  
+  def test_should_operator_expectation_returned
+    obj = 3.should
+    assert_equal Matchy::Expectations::OperatorExpectation, obj.class
+  end
+  
+  
+  def test_should_not_operator_expectation_returned
+    obj = 3.should_not
+    assert_equal Matchy::Expectations::OperatorExpectation, obj.class
+  end
+end

data/test/test_operator_expectations.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestOperatorExpectations < Test::Unit::TestCase
+  # EQUALS (==)
+  def test_equals
+    3.should == 3
+  end
+  
+  def test_equals_fails
+    lambda {
+      3.should == 5
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_equals
+    3.should_not == 4
+  end
+  
+  def test_negative_equals_fails
+    lambda {
+      3.should_not == 3
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  # LESS THAN (<)
+  def test_less_than
+    3.should < 5
+  end
+  
+  def test_less_than_fails
+    lambda {
+      4.should < 3
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_less_than_equals
+    3.should_not < 2
+  end
+  
+  def test_negative_less_than_fails
+    lambda {
+      4.should_not < 5
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end 
+  
+  # GREATER THAN (<)
+  def test_greater_than
+    3.should > 2
+  end
+  
+  def test_greater_than_fails
+    lambda {
+      4.should > 5
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_greater_than_equals
+    3.should_not > 5
+  end
+  
+  def test_negative_greater_than_fails
+    lambda {
+      4.should_not > 3
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  # LESS THAN EQUAL (<=)
+  def test_less_than_equal
+    3.should <= 5
+  end
+  
+  def test_less_than_equal_equal
+    3.should <= 3
+  end
+  
+  def test_less_than_equal_fails
+    lambda {
+      4.should <= 3
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_less_than_equal
+    3.should_not <= 2
+  end
+  
+  def test_negative_less_than_equal_fails
+    lambda {
+      4.should_not <= 5
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  # GREATER THAN EQUALS (<=)
+  def test_greater_than_equal
+    3.should >= 2
+  end
+  
+  def test_greater_than_equal_equals
+    3.should >= 3
+  end
+  
+  def test_greater_than_equal_fails
+    lambda {
+      4.should >= 5
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_greater_than_equal_equals
+    3.should_not >= 5
+  end
+  
+  def test_negative_greater_than_equal_fails
+    lambda {
+      4.should_not >= 3
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  # MATCHES (=~)
+  def test_matches
+    "hey world".should =~ /world/
+  end
+  
+  def test_matches_fails
+    lambda {
+      "d00d ur 1337".should =~ /world/
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_matches
+    "1337@age".should_not =~ /434/
+  end
+  
+  def test_negative_matches_fails
+    lambda {
+      "it's a freak out!".should_not =~ /freak/
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_fail_message
+    obj = Matchy::Expectations::OperatorExpectation.new(3, true)
+    
+    def obj.fail!(fail)
+    end
+    
+    obj == 4
+    
+    obj.send(:failure_message, "==").should =~ /Expected 3 to == 4./
+  end
+  
+  def test_negative_fail_message
+    obj = Matchy::Expectations::OperatorExpectation.new(3, true)
+    
+    def obj.fail!(fail)
+    end
+    
+    obj == 3
+    
+    obj.send(:negative_failure_message, "==").should =~ /Expected 3 to not == 3./
+  end
+end

data/test/test_truth_expectations.rb

@@ -0,0 +1,217 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Exister
+  def initialize(what)
+    @what = what
+  end
+  
+  def exist?
+    @what
+  end
+end
+
+class TestTruthExpectations < Test::Unit::TestCase
+  def test_equal
+    3.should equal(3)
+  end
+
+  def test_negative_equal
+    instance = String.new
+    
+    instance.should_not equal(String.new)
+  end
+  
+  def test_equal_fail
+    lambda {
+      3.should equal(4)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_equal_fail
+    lambda {
+      3.should_not equal(3)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+
+  def test_eql
+    3.should eql(3)
+  end
+  
+  def test_negative_eql
+    3.should_not eql(9)
+  end
+  
+  def test_eql_fail
+    lambda {
+      3.should eql(13)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_eql_fail
+    lambda {
+      3.should_not eql(3)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_exists
+    thing = Exister.new(true)
+    thing.should exist
+  end
+  
+  def test_negative_exists
+    thing = Exister.new(false)
+    thing.should_not exist
+  end
+  
+  def test_exists_fail
+    lambda {
+      thing = Exister.new(false)
+      thing.should exist
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_exists_fail
+    lambda {
+      thing = Exister.new(true)
+      thing.should_not exist
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_be
+    true.should be(true)
+  end
+  
+  def test_negative_be
+    true.should_not be(false)
+  end
+  
+  def test_be_fail
+    lambda {
+      true.should be(false)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_be_close
+    (5.0 - 2.0).should be_close(3.0)
+  end
+  
+  def test_be_close_with_delta
+    (5.0 - 2.0).should be_close(3.0, 0.2)
+  end
+  
+  def test_be_close_fail
+    lambda {
+      (19.0 - 13.0).should be_close(33.04)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_be_close_with_delta_fail
+    lambda {
+      (19.0 - 13.0).should be_close(6.0, 0.0)
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_satisfy
+    13.should satisfy(lambda {|i| i < 15})
+  end
+  
+  def test_negative_satisfy
+    13.should_not satisfy(lambda {|i| i < 10})
+  end
+  
+  def test_satisfy_fail
+    lambda {
+      13.should satisfy(lambda {|i| i > 15})
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_negative_satisfy_fail
+    lambda {
+      13.should_not satisfy(lambda {|i| i < 15})
+    }.should raise_error(Test::Unit::AssertionFailedError)
+  end
+  
+  def test_equal_fail_message
+    obj = equal(4)
+    obj.matches?(5)
+    
+    obj.failure_message.should be "Expected 5 to equal 4."
+  end
+  
+  def test_equal_negative_fail_message
+    obj = equal(5)
+    obj.matches?(5)
+    
+    obj.negative_failure_message.should be "Expected 5 to not equal 5."
+  end
+  
+  def test_eql_fail_message
+    obj = eql(4)
+    obj.matches?(5)
+    
+    obj.failure_message.should be "Expected 5 to eql 4."
+  end
+  
+  def test_eql_negative_fail_message
+    obj = eql(5)
+    obj.matches?(5)
+    
+    obj.negative_failure_message.should be "Expected 5 to not eql 5."
+  end
+  
+  def test_exist_fail_message
+    obj = exist
+    obj.matches?(Exister.new(false))
+    
+    obj.failure_message.should =~ /Expected #<(.*)> to exist./
+  end
+  
+  def test_exist_negative_fail_message
+    obj = exist
+    obj.matches?(Exister.new(true))
+    
+    obj.negative_failure_message.should =~ /Expected #<(.*)> to not exist./
+  end
+  
+  def test_be_close_fail_message
+    obj = be_close(3.0)
+    obj.matches?(6.0)
+    
+    obj.failure_message.should be "Expected 6.0 to be close to 3.0 (delta: 0.3)."
+  end
+  
+  def test_be_close_negative_fail_message
+    obj = be_close(5.0)
+    obj.matches?(5.0)
+    
+    obj.negative_failure_message.should be "Expected 5.0 to not be close to 5.0 (delta: 0.3)."
+  end
+  
+  def test_be_fail_message
+    obj = be(4)
+    obj.matches?(5)
+    
+    obj.failure_message.should be "Expected 5 to be 4."
+  end
+  
+  def test_be_negative_fail_message
+    obj = be(5)
+    obj.matches?(5)
+    
+    obj.negative_failure_message.should be "Expected 5 to not be 5."
+  end
+  
+  def test_satisfy_fail_message
+    obj = satisfy(lambda {|x| x == 4})
+    obj.matches?(6)
+    
+    obj.failure_message.should be "Expected 6 to satisfy given block."
+  end
+  
+  def test_eql_negative_fail_message
+    obj = satisfy(lambda {|x| x == 4})
+    obj.matches?(4)
+    
+    obj.negative_failure_message.should be "Expected 4 to not satisfy given block."
+  end
+end