minitest-mustwonted 1.0.0

data/README.md

@@ -0,0 +1,194 @@
+# Must Wanted Things for MiniTest
+
+This is a little plugn for [minitest](https://github.com/seattlerb/minitest)
+which contains a new `must/wont` matchers engine, a set of essential matchers
+and hooks for testing ruby/rails applications.
+
+## Usage
+
+1) Add `gem minitest-mustwonted` into your `Gemfile`
+2) Enjoy!
+
+
+## Awesome Matchers
+
+Awesome matchers are set of easy to read logic-like matchers
+
+```ruby
+describe MiniTest::MustWonted do
+  it "must provide awesome matchers" do
+    22.must == 22
+    22.wont == 33
+    22.must != 22
+
+    22.must >  11
+    22.must >= 22
+    22.must <= 23
+
+    "22".must =~ /2/
+    "22".wont =~ /3/
+  end
+end
+```
+
+## Magick Matchers
+
+Magick matchers are `rspec` like `be_smth` matchers
+
+```ruby
+describe MiniTest::MustWonted do
+  it "must provide magick matchers" do
+    [].must  be_empty
+    [0].wont be_empty
+
+    nil.must be_nil
+    '0'.wont be_nil
+
+    '0'.must be_a(String)
+    [0].must be_an(Array)
+  end
+end
+```
+
+## Collection Assertions
+
+Additional `have` matcher will let you write easily readable collection checks
+
+```ruby
+describe MiniTest::MustWonted do
+  class User
+    def comments(type=nil)
+      if type
+        Comment.where(type: type, user: self).count
+      else
+        Comment.where(user: self).count
+      end
+    end
+  end
+
+  it "must provide collection matchers" do
+    @user.must have(3).comments
+    @user.must have(1).comment(:deleted)
+
+    [1,2,3].must have(3).items
+    [1    ].must have(1).item
+  end
+end
+```
+
+__NOTE__: calls will be automatically pluralized and resolved when possible. You
+also can use the `item` or `items` on plain array-like objects, in which case it
+will be checking the `size` method by default
+
+
+## Legacy Matchers
+
+Most of the `assert_smth` | `refute_smth` methods are piped throught the `must` |
+`wont` interface automatically and resolved on fly.
+
+```ruby
+describe MiniTest::MustWonted do
+  it "must support legacy assertions" do
+    '2'.must equal(3)
+    '3'.wont equal(2)
+
+    '2'.must respond_to(:downcase)
+    [2].wont respond_to(:unknown_method)
+  end
+end
+```
+
+Note, this module will automatically use your custom `assert_something` methods
+as long as they take the subject as the first argument.
+
+
+## Validation Matchers
+
+`MustWonted` comes with a default models validation matchers similar to the
+`minitest-matchers` validation package
+
+```ruby
+describe MiniTest::MustWonted do
+  it "must provide validation matchers" do
+    @user.must have_valid(:name).with("Nikolay", "Vasilisa")
+    @user.wont have_valid(:name).with(nil, '', false)
+  end
+end
+```
+
+
+## Custom Matchers
+
+There are two ways to define your own custom matchers. Firstly, you can just
+define the `assert_your_own_stuff` and, if needed `refute_your_own_stuff` methods
+and they will be automatically available via the `must`|`wont` interface
+
+```ruby
+describe Something do
+  def assert_do_my_thing(object, *args)
+    # do something
+  end
+
+  it "must work right away" do
+    something.must do_my_thing(arg)
+  end
+
+  # if you're gonna call 'wont' as well, then define `refutre_` too
+  def refute_do_my_thing(object, *args)
+    # do something
+  end
+
+  it "wont do my thing" do
+    something.wont do_my_thing(arg)
+  ned
+end
+```
+
+If you wanna do something more serious, you can define your matcher as a class
+
+```ruby
+class MyAwesomeMatcher
+  def initialize(*args)
+    @args = args
+  end
+
+  def match?(subject, wont)
+    @args   # - the args you send into the matcher
+    subject # - the object on which you called `must`|`wont`
+    wont    # - gets `true` when you called `wont` and `false` when you called `must`
+
+    if some_awesome_check_failed
+      railse "Oh my god, we all gonna die here!"
+    end
+  end
+end
+```
+
+Once you done, register your matcher with `MiniTest::MustWonted` and start using it
+
+```ruby
+MiniTest::MustWonted :method_name, MyAwesomeMatcher
+
+describe Something do
+  it "must do something" do
+    object.must method_name(arg, arg, arg...)
+  end
+end
+```
+
+
+## Credits
+
+Most ideas were boldly taken from:
+
+[minitest-rails](https://github.com/blowmage/minitest-rails)
+[minitest-matchers](https://github.com/zenspider/minitest-matchers)
+[shoulda-matchers](https://github.com/thoughtbot/shoulda-matchers)
+[rspec-rails](https://github.com/rspec/rspec-rails)
+
+
+## Copyright
+
+All code in this library is published under the terms of the MIT License
+
+Copyright (C) 2013 Nikolay Nemshilov

data/lib/minitest-mustwonted.rb

@@ -0,0 +1,5 @@
+#
+# Gem/require hook
+#
+
+require File.dirname(__FILE__) + "/minitest/mustwonted"

data/lib/minitest/mustwonted.rb

@@ -0,0 +1,27 @@
+require 'minitest/spec'
+
+module MiniTest::MustWonted
+  VERSION = '1.0.0'
+
+  def self.add(*args)
+    MiniTest::MustWonted::Matcher.add *args
+  end
+end
+
+%w{
+  matcher
+  matcher/awesome
+  matcher/magick
+  matcher/legacy
+  matcher/valid
+  matcher/have
+  object
+  spec
+  run
+}.each do |file|
+  require File.dirname(__FILE__) + "/mustwonted/#{file}"
+end
+
+# registering the matchers
+MiniTest::MustWonted.add :have, MiniTest::MustWonted::Matcher::Have
+MiniTest::MustWonted.add :have_valid, MiniTest::MustWonted::Matcher::Valid

data/lib/minitest/mustwonted/matcher.rb

@@ -0,0 +1,31 @@
+#
+# The actual matcher engine
+#
+class MiniTest::MustWonted::Matcher
+
+  class << self
+    def must(subject, matcher=nil, flipped=false)
+      if matcher == nil
+        MiniTest::MustWonted::Matcher::Awesome.new(subject, flipped)
+      elsif matcher.respond_to?(:match?)
+        matcher.match?(subject, flipped)
+        subject # returning the reference to the subject in case of chained calls
+      else
+        raise "Your matcher supposed to have method called: 'match?'"
+      end
+    end
+
+    def wont(subject, matcher=nil)
+      must subject, matcher, true
+    end
+
+    def add(name, klass)
+      MiniTest::Unit::TestCase.instance_eval do
+        define_method name do |*args|
+          klass.new *args
+        end
+      end
+    end
+  end
+
+end

data/lib/minitest/mustwonted/matcher/awesome.rb

@@ -0,0 +1,53 @@
+#
+# Provides the awesome, pure logick like matchers
+#
+#     smth.must == smth
+#     smth.must =~ /re/
+#     smth.must > smth
+#     ...
+#
+class MiniTest::MustWonted::Matcher::Awesome
+  include MiniTest::Assertions
+
+  attr_reader :subject, :flipped
+
+  def initialize(subject, flipped)
+    @subject = subject
+    @flipped = flipped
+  end
+
+  def ==(value)
+    __call 'equal', false, @subject, value
+  end
+
+  def !=(value)
+    __call 'equal', true, @subject, value
+  end
+
+  def =~(regexp)
+    __call 'match', false, @subject, regexp
+  end
+
+  def > (value)
+    __call 'operator', false, @subject, :>, value
+  end
+
+  def < (value)
+    __call 'operator', false, @subject, :<, value
+  end
+
+  def >= (value)
+    __call 'operator', false, @subject, :>=, value
+  end
+
+  def <= (value)
+    __call 'operator', false, @subject, :<=, value
+  end
+
+private
+
+  def __call(name, flip, *args)
+    __send__ "#{@flipped == flip ? 'assert' : 'refute'}_#{name}", *args
+  end
+
+end

data/lib/minitest/mustwonted/matcher/have.rb

@@ -0,0 +1,35 @@
+#
+# The unversal `have` matcher
+#
+#     @user.must have(10).comments
+#     @array.must have(2).items
+#
+class MiniTest::MustWonted::Matcher::Have
+
+  def initialize(size)
+    @size = size
+  end
+
+  def match?(subject, wont)
+    if [:items, :item].include?(@name) && !subject.respond_to?(@name)
+      items = subject
+    else
+      items = subject.send @name, *@args
+    end
+
+    if wont ? items.size == @size : items.size != @size
+      raise MiniTest::Assertion, "Expected #{subject.inspect} to have #{
+        @size} ##{@name}(#{@args.join(',')})\nbut instead it has: #{size}"
+    end
+  end
+
+  def method_missing(name, *args)
+    name = name.pluralize if name.respond_to?(:pluralize)
+
+    @name = name.to_sym
+    @args = args
+
+    self # returning itself so the end result was always this matcher
+  end
+
+end

data/lib/minitest/mustwonted/matcher/legacy.rb

@@ -0,0 +1,26 @@
+#
+# This matcher automatically calls the legacy `must_smth`, `refute_something`
+# matchers if they are exists
+#
+class MiniTest::MustWonted::Matcher::Legacy
+
+  def initialize(name, args, test)
+    @name = name
+    @args = args
+    @test = test
+  end
+
+  def match?(subject, wont)
+    # trying the must_smth|wont_smth first, coz they expect the subject first
+    if subject.respond_to?(name = "#{wont ? 'wont' : 'must'}_#{@name}")
+      subject.__send__ name, *@args
+
+    # falling back to aseert|refute methods in case
+    elsif @test.respond_to?(name = "#{wont ? 'refute' : 'assert'}_#{@name}")
+      @test.__send__ name, subject, *@args
+    elsif wont
+      raise "Couldn't find the '#{wont ? 'refute' : 'assert'}_#{@name}' matcher"
+    end
+  end
+
+end

data/lib/minitest/mustwonted/matcher/magick.rb

@@ -0,0 +1,23 @@
+#
+# The Magick `be_smth` matcher
+#
+class MiniTest::MustWonted::Matcher::Magick
+
+  def initialize(name, args)
+    @name = name.slice(3, name.size)
+    @name+= '?' if name[name.size - 1] != '?'
+    @args = args
+  end
+
+  def match?(subject, wont)
+    @name = 'is_a?' if @name == 'a?' || @name == 'an?'
+    match = subject.send @name, *@args
+
+    if wont ? match : !match
+      raise MiniTest::Assertion, "Expected #{subject.inspect} ##{
+        @name} to return: #{ wont ? "false" : "true"
+      }\nbut instead have: #{match.inspect}"
+    end
+  end
+
+end

data/lib/minitest/mustwonted/matcher/valid.rb

@@ -0,0 +1,49 @@
+#
+# Generic validations matcher
+#
+#     user.must have_valid(:name)
+#     user.must have_valid(:name).with('Nikolay', 'Vasilisa', ...)
+#     user.wont have_valid(:name).with(nil, '', false)
+#
+# Credits: we're mimicking the minitest-matchers validation matchers here
+#
+class MiniTest::MustWonted::Matcher::Valid
+  def initialize(name)
+    @name = name.to_sym
+    @args = []
+  end
+
+  def match?(subject, wont)
+    if @args.size == 0
+      test!(subject, wont)
+    else
+      @args.each do |value|
+        subject.send "#{@name}=", value
+        test!(subject, wont)
+      end
+    end
+  end
+
+  def with(*args)
+    @args = args
+
+    self
+  end
+
+  def test!(subject, wont)
+    valid = subject.valid?
+    error = subject.errors[@name]
+
+    if error && !wont
+      raise MiniTest::Assertion, "Expected the #{
+        subject.inspect} to have valid #{@name
+        } with #{subject.send(@name).inspect
+        }\nbut had an error instead: #{error.inspect}"
+    elsif wont && !error
+      raise MiniTest::Assertion, "Expected the #{
+        subject.inspect} to have invalid #{@name
+        } with #{subject.send(@name).inspect
+        }\nbut had no errors for this field instead"
+    end
+  end
+end

data/lib/minitest/mustwonted/object.rb

@@ -0,0 +1,26 @@
+#
+# The object level `must` | `wont` hooks
+#
+class Object
+  #
+  # kicks in the `must` assertion on the object
+  #
+  #     smth.must smth
+  #     smth.must == somth
+  #     ....
+  #
+  def must(*args)
+    MiniTest::MustWonted::Matcher.must(self, *args)
+  end
+
+  #
+  # kicks in the `wont` assertion on the object
+  #
+  #     smth.wont smth
+  #     smth.wont == somth
+  #     ....
+  #
+  def wont(*args)
+    MiniTest::MustWonted::Matcher.wont(self, *args)
+  end
+end

data/lib/minitest/mustwonted/run.rb

@@ -0,0 +1,8 @@
+#
+# Console runnner
+#
+module MiniTest::MustWonted
+  def self.run(args)
+    puts args
+  end
+end

data/lib/minitest/mustwonted/spec.rb

@@ -0,0 +1,41 @@
+#
+# Extra sweets for the MiniTest::Spec unit
+#
+class MiniTest::Spec
+
+  #
+  # A shortcut to `must` directly on current subject
+  #
+  #     subject { Something.new }
+  #
+  #     it { must do_something }
+  #
+  def must(*args)
+    subject.must(*args)
+  end
+
+  #
+  # A shortcut to `wont` directly on current subject
+  #
+  #     subject { Something.new }
+  #
+  #     it { wont do_something }
+  #
+  def wont(*args)
+    subject.wont(*args)
+  end
+
+  #
+  # Catching up the magick `be_smthing?` matchers
+  #
+  def method_missing(name, *args)
+    if name.slice(0, 3) == 'be_'
+      MiniTest::MustWonted::Matcher::Magick.new(name, args)
+    elsif respond_to?("assert_#{name}")
+      MiniTest::MustWonted::Matcher::Legacy.new(name, args, self)
+    else
+      super name, *args
+    end
+  end
+
+end

data/test/mustwonted/matcher/awesome_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+describe MiniTest::MustWonted::Matcher::Awesome do
+
+  describe "==" do
+    it "must test correctly" do
+      "22".must == "22"
+      "22".wont == "33"
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ "22".must == "33" }
+      assert_fails_correctly{ "22".wont == "22" }
+    end
+  end
+
+  describe "!=" do
+    it "must test correctly" do
+      "22".must != "33"
+      "22".wont != "22"
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ "22".must != "22" }
+      assert_fails_correctly{ "22".wont != "33" }
+    end
+  end
+
+  describe "=~" do
+    it "must test correctly" do
+      "22".must =~ /2/
+      "22".wont =~ /3/
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ "22".must =~ /3/ }
+      assert_fails_correctly{ "22".wont =~ /2/ }
+    end
+  end
+
+  describe ">" do
+    it "must test correctly" do
+      22.must > 11
+      22.wont > 33
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ 22.must > 33 }
+      assert_fails_correctly{ 22.must > 22 }
+      assert_fails_correctly{ 22.wont > 11 }
+      assert_fails_correctly{ 22.wont > 21 }
+    end
+  end
+
+  describe "<" do
+    it "must test correctly" do
+      22.must < 33
+      22.wont < 11
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ 22.must < 11 }
+      assert_fails_correctly{ 22.must < 22 }
+      assert_fails_correctly{ 22.wont < 33 }
+      assert_fails_correctly{ 22.wont < 23 }
+    end
+  end
+
+  describe ">=" do
+    it "must test correctly" do
+      22.must >= 11
+      22.must >= 22
+      22.wont >= 33
+      22.wont >= 23
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ 22.must >= 33 }
+      assert_fails_correctly{ 22.must >= 23 }
+      assert_fails_correctly{ 22.wont >= 22 }
+      assert_fails_correctly{ 22.wont >= 11 }
+    end
+  end
+
+  describe "<=" do
+    it "must test correctly" do
+      22.must <= 33
+      22.must <= 23
+      22.wont <= 21
+      22.wont <= 11
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ 22.must <= 11 }
+      assert_fails_correctly{ 22.must <= 21 }
+      assert_fails_correctly{ 22.wont <= 22 }
+      assert_fails_correctly{ 22.wont <= 33 }
+    end
+  end
+end

data/test/mustwonted/matcher/have_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+describe MiniTest::MustWonted::Matcher::Have do
+
+  describe 'simple case' do
+    subject{ Struct.new(:dogs, :cats).new([1,2,3],[1,2]) }
+
+    it "must check correctly" do
+      subject.must have(3).dogs
+      subject.must have(2).cats
+
+      subject.wont have(2).dogs
+      subject.wont have(3).cats
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ subject.must have(3).cats }
+      assert_fails_correctly{ subject.wont have(2).cats }
+    end
+  end
+
+  describe 'case with extra arguments' do
+    class Subject
+      DOGS = {large: [1,2,3,4], small: [1,2]}
+
+      def dogs(size=nil)
+        if size
+          DOGS[size]
+        else
+          DOGS[:large] + DOGS[:small]
+        end
+      end
+    end
+
+    subject { Subject.new }
+
+    it "must handle everything correctly" do
+      subject.must have(4).dogs(:large)
+      subject.must have(2).dogs(:small)
+      subject.must have(6).dogs
+
+      subject.wont have(2).dogs(:large)
+      subject.wont have(3).dogs(:small)
+      subject.wont have(4).dogs
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ subject.must have(3).dogs(:large) }
+      assert_fails_correctly{ subject.wont have(4).dogs(:large) }
+    end
+  end
+
+  describe "fallback with the 'items'" do
+    it "must handle 'items' call as the size one" do
+      [1,2,3].must have(3).items
+      [1    ].must have(1).item
+
+      [1,2,3].wont have(5).items
+      [1,2  ].wont have(1).item
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ [1,2].must have(5).items }
+      assert_fails_correctly{ [1,2].wont have(2).items }
+    end
+  end
+
+end

data/test/mustwonted/matcher/legacy_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+describe MiniTest::MustWonted::Matcher::Legacy do
+
+  describe "simple case" do
+    it "must be handled correctly" do
+      '3'.must equal('3')
+      [3].must equal([3])
+
+      '2'.wont equal('3')
+      [2].wont equal([3])
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly{ '2'.must equal('3') }
+      assert_fails_correctly{ '2'.wont equal('2') }
+    end
+  end
+
+  describe "custom made assertions" do
+    subject { 'subject' }
+
+    def assert_do_custom_stuff(subj, value)
+      assert_equal subj,  subject
+      assert_equal value, 3
+    end
+
+    it "should catch up with them correctly" do
+      subject.must do_custom_stuff(3)
+    end
+
+    it "must fail when called with 'wont' coz there's no refute" do
+      assert_raises RuntimeError, "Couldn't find the 'refute_do_custom_stuff' matcher" do
+        subject.wont do_custom_stuff(3)
+      end
+    end
+  end
+
+end

data/test/mustwonted/matcher/magick_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+describe MiniTest::MustWonted::Matcher::Magick do
+
+  describe "plain calls" do
+
+    it "must be handled correctly" do
+      [].must be_empty
+      [].must be_empty?
+
+      [0].wont be_empty
+      [0].wont be_empty?
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly { [0].must be_empty  }
+      assert_fails_correctly { [0].must be_empty? }
+      assert_fails_correctly { [].wont be_empty   }
+      assert_fails_correctly { [].wont be_empty?  }
+    end
+
+  end
+
+  describe "calls with arguments" do
+    class BeTest
+      def tested?(one, two)
+        one > two
+      end
+    end
+
+    subject { BeTest.new }
+
+    it "must handle params correctly" do
+      must be_tested(2, 1)
+      wont be_tested(1, 2)
+    end
+
+    it "must fail correctly" do
+      assert_fails_correctly { must be_tested(1, 2) }
+      assert_fails_correctly { wont be_tested(2, 1) }
+    end
+  end
+
+  describe 'be_a/be_an matchers' do
+    it "must handle them correctly" do
+      '0'.must be_a(String)
+      [0].must be_an(Array)
+
+      '0'.wont be_an(Array)
+      [0].wont be_a(String)
+    end
+  end
+
+end

data/test/mustwonted/matcher/valid_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+describe MiniTest::MustWonted::Matcher::Valid do
+
+  class User
+    attr_accessor :name, :email, :errors
+
+    def initialize(params)
+      @name  = params[:name]
+      @email = params[:email]
+    end
+
+    def valid?
+      @errors = {}
+
+      @errors[:name]  = ["Can't be blank"] if !@name
+      @errors[:email] = ["Can't be blank"] if !@email
+
+      @errors.size == 0
+    end
+  end
+
+  describe "without options" do
+    it "must validate objects correctly" do
+      user = User.new(name: 'Nikolay', email: 'nikolay@theosom.com')
+
+      user.must have_valid(:name)
+      user.must have_valid(:email)
+    end
+
+    it "must invalidate objects correctly" do
+      user = User.new({})
+
+      user.wont have_valid(:name)
+      user.wont have_valid(:email)
+    end
+
+    it "must fail correctly" do
+      user = User.new(name: 'Nikolay')
+
+      assert_fails_correctly{ user.must have_valid(:email) }
+      assert_fails_correctly{ user.wont have_valid(:name)  }
+    end
+  end
+
+  describe "with a list of options" do
+    let(:user) { User.new({}) }
+
+    it "must validate objects correctly" do
+      user.must have_valid(:name).with('Nikolay', 'Vasilisa')
+      user.must have_valid(:email).with('nikolay@theosom.com', 'vasilisa@theosom.com')
+    end
+
+    it "must invalidate objects correctly" do
+      user.wont have_valid(:name).with(nil,  false)
+      user.wont have_valid(:email).with(nil, false)
+    end
+
+    it "must fail correctly with wrong data" do
+      assert_fails_correctly{ user.must have_valid(:name).with(nil) }
+      assert_fails_correctly{ user.wont have_valid(:name).with("Nikolay") }
+    end
+  end
+
+end

data/test/mustwonted/matcher_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+describe MiniTest::MustWonted::Matcher do
+  subject{ nil }
+
+  Matcher = MiniTest::MustWonted::Matcher
+
+  describe ".must" do
+    describe "without a matcher" do
+      let(:matcher) { Matcher.must(subject) }
+
+      it "must create an Awesome matcher" do
+        assert_instance_of Matcher::Awesome, matcher
+      end
+
+      it "must assign the current subject to the matcher" do
+        matcher.subject.must_equal subject
+      end
+
+      it "must set the matcher as a straight one" do
+        matcher.flipped.must_equal false
+      end
+    end
+  end
+
+  describe ".wont" do
+    describe "without a matcher" do
+      let(:matcher) { Matcher.wont(subject) }
+
+      it "must create an Awesome matcher" do
+        assert_instance_of Matcher::Awesome, matcher
+      end
+
+      it "must assign the current subject to the matcher" do
+        matcher.subject.must_equal subject
+      end
+
+      it "must set the matcher as a flipped one" do
+        matcher.flipped.must_equal true
+      end
+    end
+  end
+
+end

data/test/mustwonted/object_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+describe Object do
+
+  subject { nil }
+
+  describe "#must" do
+    it "must be present on any object" do
+      assert subject.respond_to?(:must)
+    end
+
+    it "must bypass the call into Matcher.must" do
+      MiniTest::MustWonted::Matcher.expects(:must).with(subject, 'something')
+
+      subject.must 'something'
+    end
+  end
+
+  describe "#wont" do
+    it "must be present on any object" do
+      assert subject.respond_to?(:wont)
+    end
+
+    it "must bypass the call into Matcher.wont" do
+      MiniTest::MustWonted::Matcher.expects(:wont).with(subject, 'something')
+
+      subject.wont 'something'
+    end
+  end
+
+end

data/test/mustwonted/spec_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+
+describe MiniTest::Spec do
+  subject { {} }
+
+  it "must allow to use must" do
+    assert respond_to?(:must)
+  end
+
+  it "must allow to use wont" do
+    assert respond_to?(:wont)
+  end
+
+  it "should bypass the 'must' calls to the current subject" do
+    subject.expects(:must).with('something')
+    must 'something'
+  end
+
+  it "should bypass the 'wont' calls to the current subject" do
+    subject.expects(:wont).with('something')
+    wont 'something'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require_relative "../lib/minitest-mustwonted"
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'mocha/setup'
+
+class MiniTest::Spec
+  def assert_fails_correctly
+    # TODO make sure that the errors are raised with correct file/line references
+    -> { yield }.must_raise MiniTest::Assertion
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: minitest-mustwonted
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Nikolay Nemshilov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-29 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: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides a new unversal and esily extendable matchers engine
+email: nemshilov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/minitest/mustwonted/matcher/awesome.rb
+- lib/minitest/mustwonted/matcher/have.rb
+- lib/minitest/mustwonted/matcher/legacy.rb
+- lib/minitest/mustwonted/matcher/magick.rb
+- lib/minitest/mustwonted/matcher/valid.rb
+- lib/minitest/mustwonted/matcher.rb
+- lib/minitest/mustwonted/object.rb
+- lib/minitest/mustwonted/run.rb
+- lib/minitest/mustwonted/spec.rb
+- lib/minitest/mustwonted.rb
+- lib/minitest-mustwonted.rb
+- test/mustwonted/matcher/awesome_test.rb
+- test/mustwonted/matcher/have_test.rb
+- test/mustwonted/matcher/legacy_test.rb
+- test/mustwonted/matcher/magick_test.rb
+- test/mustwonted/matcher/valid_test.rb
+- test/mustwonted/matcher_test.rb
+- test/mustwonted/object_test.rb
+- test/mustwonted/spec_test.rb
+- test/test_helper.rb
+- README.md
+homepage: http://github.com/MadRabbit/minitest-mustwonted
+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.23
+signing_key: 
+specification_version: 3
+summary: new must/wont matchers engine for minitest
+test_files: []