minitest-chain 0.5.0

data/lib/minitest-chain.rb

@@ -0,0 +1,61 @@
+require 'minitest/unit'
+
+module MiniTest::Chain
+  class AssertionChain
+    def initialize(scope, obj)
+      @scope = scope
+      @obj = obj
+    end
+
+    # Flippers:
+    [
+      [:equal, :equal],
+      [:match, :match],
+      [:close_to, :in_delta],
+      [:within_epsilon, :in_epsilon],
+      [:instance_of, :instance_of],
+      [:same, :same],
+    ].each do |name, assertion|
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{name}(other, *args)
+          @scope.assert_#{assertion}(other, @obj, *args)
+          self
+        end
+
+        def not_#{name}(other, *args)
+          @scope.refute_#{assertion}(other, @obj, *args)
+          self
+        end
+      RUBY
+    end
+
+    # Unaries and reversers:
+    [
+      [:empty, :empty],
+      [:include, :includes],
+      [:is, :operator],
+      [:respond_to, :respond_to],
+    ].each do |name, assertion|
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{name}(*args)
+          @scope.assert_#{assertion}(@obj, *args)
+          self
+        end
+
+        def not_#{name}(*args)
+          @scope.refute_#{assertion}(@obj, *args)
+          self
+        end
+      RUBY
+    end
+
+    alias is_not not_is
+    remove_method :not_is
+  end
+
+  def assert(obj, *args)
+    super
+    AssertionChain.new(self, obj)
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,4 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'minitest/autorun'
+require 'minitest-chain'
+

data/test/test_chain.rb

@@ -0,0 +1,116 @@
+require_relative 'helper'
+
+class TestChain < MiniTest::Unit::TestCase
+  include MiniTest::Chain
+
+  def assert_refutes
+    assert_raises(MiniTest::Assertion) do
+      yield
+    end
+  end
+
+  def test_equal
+    assert("Hello").equal("Hello")
+    assert("World").not_equal("Hello")
+
+    assert_refutes { assert("World").equal("Hello") }
+    assert_refutes { assert("Hello").not_equal("Hello") }
+  end
+
+  def test_match
+    assert("World").match(/World/)
+    assert("Hello").not_match(/World/)
+
+    assert_refutes { assert("Hello").match(/World/) }
+    assert_refutes { assert("World").not_match(/World/) }
+  end
+
+  def test_empty
+    assert([]).empty
+    assert([1]).not_empty
+
+    assert_refutes { assert([1]).empty }
+    assert_refutes { assert([]).not_empty }
+  end
+
+  def test_includes
+    assert([1]).include(1)
+    assert([2]).not_include(1)
+
+    assert_refutes { assert([2]).include(1) }
+    assert_refutes { assert([1]).not_include(1) }
+  end
+
+  def test_close_to
+    assert(1.5).close_to(1.5)
+    assert(2.0).not_close_to(1.5)
+
+    assert_refutes { assert(2.0).close_to(1.5) }
+    assert_refutes { assert(1.5).not_close_to(1.5) }
+  end
+
+  def test_within_epsilon
+    assert(1.6).within_epsilon(1.5, 0.10)
+
+    assert_refutes do
+      assert(1.9).within_epsilon(1.5, 0.10)
+    end
+  end
+
+  def test_instance_of
+    assert(1  ).instance_of(Fixnum)
+    assert(1.5).not_instance_of(Fixnum)
+
+    assert_refutes { assert(1.5).instance_of(Fixnum) }
+    assert_refutes { assert(1  ).not_instance_of(Fixnum) }
+  end
+
+  def test_is
+    assert(1).is(:<, 2)
+    assert(3).is_not(:<, 2)
+
+    assert_refutes { assert(3).is(:<, 2) }
+    assert_refutes { assert(1).is_not(:<, 2) }
+  end
+
+  def test_not_is
+    assert_raises(NoMethodError) do
+      assert(1).not_is(:zero?)
+    end
+  end
+
+  def test_is_predicate
+    assert([]).is(:empty?)
+    assert([1]).is_not(:empty?)
+
+    assert_refutes { assert([1]).is(:empty?) }
+    assert_refutes { assert([]).is_not(:empty?) }
+  end
+
+  def test_respond_to
+    assert([]).respond_to(:empty?)
+    assert(1).not_respond_to(:empty?)
+
+    assert_refutes { assert(1).respond_to(:empty?) }
+    assert_refutes { assert([]).not_respond_to(:empty?) }
+  end
+
+  def test_same
+    a = Object.new
+    b = Object.new
+
+    assert(a).same(a)
+    assert(a).not_same(b)
+
+    assert_refutes { assert(a).same(b) }
+    assert_refutes { assert(a).not_same(a) }
+  end
+
+  def test_chain
+    assert(1)
+      .is(:>, 0)
+      .equal(1)
+      .instance_of(Fixnum)
+  end
+end
+

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: minitest-chain
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- Magnus Holm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Chainable assertions for MiniTest
+email: judofyr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- test/helper.rb
+- test/test_chain.rb
+- lib/minitest-chain.rb
+homepage: https://github.com/judofyr/minitest-chain
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Chainable assertions for MiniTest
+test_files:
+- test/helper.rb
+- test/test_chain.rb