minitest-matchers 1.0.3 → 1.1.0.rc2

data/.autotest

@@ -3,24 +3,6 @@
 require "autotest/restart"
 
 Autotest.add_hook :initialize do |at|
-  at.testlib = "minitest/autorun"
+  at.testlib = ".minitest"
   at.add_exception "tmp"
-
-#   at.extra_files << "../some/external/dependency.rb"
-#
-#   at.libs << ":../some/external"
-#
-#   at.add_exception "vendor"
-#
-#   at.add_mapping(/dependency.rb/) do |f, _|
-#     at.files_matching(/test_.*rb$/)
-#   end
-#
-#   %w(TestA TestB).each do |klass|
-#     at.extra_class_map[klass] = "test/test_misc.rb"
-#   end
 end
-
-# Autotest.add_hook :run_command do |at|
-#   system "rake build"
-# end

data/README.txt

@@ -5,33 +5,71 @@
 == DESCRIPTION:
 
 minitest-matchers adds support for RSpec/Shoulda-style matchers to
-MiniTest::Spec.
+minitest/unit and minitest/spec.
 
-A matcher is a class that must implement #description and #matches?
-methods. Expactations are then builded using these two methods.
+A matcher is a class that must implement #description, #matches?,
+#failure_message and #negative_failure_message methods.
+Expactations are then builded using these methods.
 
 == FEATURES/PROBLEMS:
 
-* Enables you to define reusable matcher classes
+* Enables you to use existing matcher classes from projects like
+  valid_attribute, (with some additional work) shoulda-matchers and remarkable.
 
 == SYNOPSIS:
 
-* see https://github.com/bcardarella/valid_attribute (support coming soon hopefully!)
+* see example matcher: https://github.com/bcardarella/valid_attribute/blob/master/lib/valid_attribute/matcher.rb
 
-    class Post < ActiveRecord::Base
+    gem "minitest"
+    require "minitest/matchers"
+    require "minitest/autorun"
+    require "valid_attribute"
+    require "active_model"
+
+    class Post
+      include ActiveModel::Validations
+      attr_accessor :title
       validates :title, :presence => true, :length => 4..20
     end
 
+    # Using minitest/unit
+
+    class PostTest < MiniTest::Unit::TestCase
+      include ValidAttribute::Method
+
+      def test_validations
+        post = Post.new
+
+        assert_must have_valid(:title).when("Good"), post
+        assert_wont have_valid(:title).when(""), post
+      end
+    end
+
+    # Using minitest/spec
+
+    describe Post do
+      include ValidAttribute::Method
+
+      it "should have validations" do
+        post = Post.new
+
+        post.must have_valid(:title).when("Good")
+        post.wont have_valid(:title).when("")
+      end
+    end
+
+    # Using minitest/spec with subject
+
     describe Post do
       subject { Post.new }
 
-      must { have_valid(:title).when("Hello") }
-      wont { have_valid(:title).when(nil, "", "Bad") }
+      it { must have_valid(:title).when("Hello") }
+      it { wont have_valid(:title).when("", nil, "Bad") }
     end
 
 == REQUIREMENTS:
 
-* minitest > 2.5.0
+* minitest >= 2.7.0
 
 == INSTALL:
 

data/lib/minitest/matchers.rb

@@ -1,59 +1,124 @@
 require "minitest/spec"
 
 module MiniTest::Matchers
-  VERSION = "1.0.3"
+  VERSION = "1.1.0.rc2" # :nodoc:
 
-  def must &block
-    matcher = yield
-    check_matcher matcher
+  ##
+  # Every matcher must respond to following methods:
+  #   - #description
+  #   - #matches?
+  #   - #failure_message
+  #   - #negative_failure_message
 
-    it "must #{matcher.description}" do
+  def self.check_matcher matcher
+    [:description, :matches?, :failure_message, :negative_failure_message].each do |m|
+      unless matcher.respond_to? m
+        fail "Matcher must respond to #{m}."
+      end
+    end
+  end
+end
+
+module MiniTest
+  module Assertions
+    ##
+    # Fails unless matcher.matches?(subject) returns true
+    #
+    # Example:
+    #
+    #   def test_validations
+    #     assert_must be_valid, @user
+    #   end
+
+    def assert_must matcher, subject, msg = nil
+      MiniTest::Matchers.check_matcher matcher
       result = matcher.matches? subject
 
-      failure_message = if matcher.respond_to? :failure_message
-                          matcher.failure_message
-                        else
-                          "expected to " + matcher.description
-                        end
+      msg = message(msg) { matcher.failure_message }
 
-      assert result, failure_message
+      assert result, msg
     end
 
-    matcher
+    ##
+    # Fails if matcher.matches?(subject) returns true
+    #
+    # Example:
+    #
+    #   def test_validations
+    #     assert_wont be_valid, @user
+    #   end
+
+    def assert_wont matcher, subject, msg = nil
+      MiniTest::Matchers.check_matcher matcher
+      result = matcher.matches? subject
+
+      msg = message(msg) { matcher.negative_failure_message }
+
+      refute result, msg
+    end
   end
 
-  def wont &block
-    matcher = yield
-    check_matcher matcher
+  module Expectations
+    ##
+    # See MiniTest::Assertions#assert_must
+    #
+    #     user.must have_valid(:email).when("user@example.com")
+    #
+    # :method: must
 
-    it "wont #{matcher.description}" do
-      result = if matcher.respond_to? :does_not_match?
-                 matcher.does_not_match?(subject)
-               else
-                 !matcher.matches?(subject)
-               end
+    infect_an_assertion :assert_must, :must
 
-      failure_message = if matcher.respond_to? :negative_failure_message
-                          matcher.negative_failure_message
-                        else
-                          "expected not to " + matcher.description
-                        end
+    ##
+    # See MiniTest::Assertions#assert_wont
+    #
+    #     user.wont have_valid(:email).when("bad@email")
+    #
+    # :method: wont
 
-      assert result, failure_message
-    end
+    infect_an_assertion :assert_wont, :wont
+  end
+end
+
+class MiniTest::Spec
+  ##
+  # Define a `must` expectation for implicit subject
+  #
+  # Example:
+  #
+  #   describe Post do
+  #     subject { Post.new }
+  #
+  #     it { must have_valid(:title).when("Good") }
+  #   end
 
-    matcher
+  def must(*args, &block)
+    if respond_to?(:subject)
+      subject.must(*args, &block)
+    else
+      super
+    end
   end
 
-  def check_matcher matcher
-    [:description, :matches?].each do |m|
-      if !matcher.respond_to?(m) || matcher.send(:description).nil?
-        fail "Matcher must respond to #{m}"
-      end
+  ##
+  # Define a `wont` expectation for implicit subject
+  #
+  # Example:
+  #
+  #   describe Post do
+  #     subject { Post.new }
+  #
+  #     it { wont have_valid(:title).when("") }
+  #   end
+
+  def wont(*args, &block)
+    if respond_to?(:subject)
+      subject.wont(*args, &block)
+    else
+      super
     end
   end
 end
 
-class MiniTest::Spec
-  extend MiniTest::Matchers
+class MiniTest::Spec # :nodoc:
+  include MiniTest::Matchers
 end

data/test/test_minitest_matchers.rb

@@ -1,3 +1,5 @@
+gem "minitest"
+require "minitest/spec"
 require "minitest/autorun"
 require "minitest/matchers"
 
@@ -8,75 +10,83 @@ class KindOfMatcher
     @klass = klass
   end
 
-  def description; "be kind of #{@klass}" end
+  def description
+    "be kind of #{@klass}"
+  end
+
+  def matches? subject
+    subject.kind_of?  @klass
+  end
 
-  def matches? subject; subject.kind_of? @klass end
+  def failure_message
+    "expected to " + description
+  end
+
+  def negative_failure_message
+    "expected not to " + description
+  end
 end
 
-class BadSpec < MiniTest::Spec; end
-class GoodSpec < MiniTest::Spec
-  subject { [1, 2, 3] }
+def be_kind_of klass
+  KindOfMatcher.new klass
 end
 
-describe MiniTest::Matchers do
-  let(:bad_spec)  { Class.new(BadSpec) }
-  let(:good_spec) { Class.new(GoodSpec) }
+describe MiniTest::Unit::TestCase do
+  it "needs to verify matcher has #description and #matches?" do
+    proc { assert_must BadMatcher.new, [] }.must_raise RuntimeError
+  end
 
-  describe "check_matcher" do
-    it "requires spec to have subject" do
-      proc { bad_spec.must { BadMatcher.new } }.must_raise RuntimeError
-    end
+  it "needs to verify assert_must" do
+    assert_must(be_kind_of(Array), []).must_equal true
+    proc { assert_must be_kind_of(String), [] }.must_raise MiniTest::Assertion
+  end
 
-    it "requires matcher to have #description and #matches?" do
-      proc { good_spec.must { BadMatcher.new } }.must_raise RuntimeError
-      good_spec.must { KindOfMatcher.new(Object) }.must_be_kind_of KindOfMatcher
-    end
+  it "needs to verify assert_wont" do
+    assert_wont(be_kind_of(String), []).must_equal false
+    proc { assert_wont be_kind_of(Array), [] }.must_raise MiniTest::Assertion
+  end
+end
+
+describe MiniTest::Spec do
+  it "needs to verify matcher has #description and #matches?" do
+    proc { [].must BadMatcher.new, [] }.must_raise RuntimeError
   end
 
-  describe "must" do
-    subject do
-      Class.new(good_spec) do
-        must { KindOfMatcher.new String }
-      end
-    end
+  it "needs to verify must" do
+    [].must(be_kind_of(Array)).must_equal true
+    proc { [].must be_kind_of(String) }.must_raise MiniTest::Assertion
+  end
 
-    let(:spec) { subject.new "A spec" }
+  it "needs to verify wont" do
+    [].wont(be_kind_of(String)).must_equal false
+    proc { [].wont be_kind_of(Array) }.must_raise MiniTest::Assertion
+  end
 
-    it "defines must expectation" do
-      subject.test_methods.grep(/must_be_kind_of/).size.must_equal 1
-    end
+  it "needs to verify must with implicit subject" do
+    spec_class = Class.new(MiniTest::Spec) do
+      subject { [1, 2, 3] }
 
-    it "passes when matches" do
-      subject.send(:subject) { "hello" }
-      proc { spec.send subject.test_methods.first }
+      it("1") { must be_kind_of(Array) }
+      it("2") { must be_kind_of(String) }
     end
 
-    it "raises error when does not match" do
-      subject.send(:subject) { 1 }
-      proc { spec.send subject.test_methods.first }.must_raise MiniTest::Assertion
-    end
+    spec = spec_class.new("A spec")
+
+    spec.send "test_0001_1"
+    proc { spec.send "test_0002_2"}.must_raise MiniTest::Assertion
   end
 
-  describe "wont" do
-    subject do
-      Class.new(good_spec) do
-        wont { KindOfMatcher.new String }
-      end
-    end
-    let(:spec) { subject.new "A spec" }
+  it "needs to verify wont with implicit subject" do
+    spec_class = Class.new(MiniTest::Spec) do
+      subject { [1, 2, 3] }
 
-    it "defines wont expectation" do
-      subject.test_methods.grep(/wont_be_kind_of/).size.must_equal 1
+      it("1") { wont be_kind_of(String) }
+      it("2") { wont be_kind_of(Array) }
     end
 
-    it "passes when does not match" do
-      subject.send(:subject) { 1 }
-      proc { spec.send subject.test_methods.first }
-    end
+    spec = spec_class.new("A spec")
 
-    it "raises error when matches" do
-      subject.send(:subject) { "hello" }
-      proc { spec.send subject.test_methods.first }.must_raise MiniTest::Assertion
-    end
+    spec.send "test_0001_1"
+    proc { spec.send "test_0002_2"}.must_raise MiniTest::Assertion
   end
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: minitest-matchers
 version: !ruby/object:Gem::Version
-  version: 1.0.3
-  prerelease: 
+  version: 1.1.0.rc2
+  prerelease: 6
 platform: ruby
 authors:
 - Ryan Davis
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-05 00:00:00.000000000Z
+date: 2011-11-03 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &70212276375280 !ruby/object:Gem::Requirement
+  requirement: &70279503203140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,21 +22,21 @@ dependencies:
         version: 2.5.0
   type: :runtime
   prerelease: false
-  version_requirements: *70212276375280
+  version_requirements: *70279503203140
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &70212276374860 !ruby/object:Gem::Requirement
+  requirement: &70279503202320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '2.7'
   type: :development
   prerelease: false
-  version_requirements: *70212276374860
+  version_requirements: *70279503202320
 - !ruby/object:Gem::Dependency
   name: hoe
-  requirement: &70212276374440 !ruby/object:Gem::Requirement
+  requirement: &70279503201140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,15 +44,8 @@ dependencies:
         version: '2.12'
   type: :development
   prerelease: false
-  version_requirements: *70212276374440
-description: ! 'minitest-matchers adds support for RSpec/Shoulda-style matchers to
-
-  MiniTest::Spec.
-
-
-  A matcher is a class that must implement #description and #matches?
-
-  methods. Expactations are then builded using these two methods.'
+  version_requirements: *70279503201140
+description: methods.
 email:
 - ryand-ruby@zenspider.com
 - wojtek@wojtekmach.pl
@@ -88,14 +81,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: minitest-matchers
-rubygems_version: 1.8.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: minitest-matchers adds support for RSpec/Shoulda-style matchers to MiniTest::Spec
+summary: methods.
 test_files:
 - test/test_minitest_matchers.rb