minitest-bonus-assertions 1.0 → 2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34a1d4e2eb4c1707a301a7c716e5d8f39c961ff1
-  data.tar.gz: 7d72041f067772a9634b299c9cb9eecc7ba337f4
+  metadata.gz: 4bb8c4387ba54e4575d49e45cd8103bc70b1ea4c
+  data.tar.gz: 6cd36802e22704ea0e698352589392d19d140c6b
 SHA512:
-  metadata.gz: 90691c38fede3f41b44f488646e67d3f5626c602361f775ecd3ae3423fe6e7381bb9c9ba5c53c1b8723ccba2460876c5dc3cb00369c9536b075a7ea12a898850
-  data.tar.gz: 17bd17bba6f87c5f128723eeb2932d3be938275c8a8ff478cf62a9d8c67faa8124cdb2eef3dc689bf5f3c109cd53e0385c799edb2774bb4cf4492f211c415810
+  metadata.gz: 587007bba2f0d47fed2ab3559b0a244cc2077c2c502a3c9a38fdd1fa756ec00d58f28713421138f84affdc89a52ec1cd65da72dde93cbd695666e80bbfd1dec7
+  data.tar.gz: b6773e5c6bb397bc4299864f3781a2b74a12232de8d43d3c25b4be3f0bc5655983439f0ddc527a9053021020b430abd81c6c1b8e83c463207dd47da62314bec6

data/.travis.yml

@@ -1,16 +1,17 @@
 ---
 language: ruby
 rvm:
-  - 2.2.0
-  - 2.1.0
-  - 2.0.0
-  - 1.9.3
+  - 2.2.3
+  - 2.1.7
+  - 2.0.0-p647
   - ruby-head
+  - jruby-9.0
   - jruby-19mode
   - jruby-head
   - rbx-2
 matrix:
   allow_failures:
+    - rvm: 1.9.3
     - rvm: rbx-2
     - rvm: jruby-head
     - rvm: ruby-head
@@ -33,3 +34,4 @@ notifications:
       - halostatue@gmail.com
     on_success: change
     on_failure: always
+sudo: false

data/Code-of-Conduct.rdoc

@@ -0,0 +1,41 @@
+==  Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct. By adopting this Code of Conduct,
+project maintainers commit themselves to fairly and consistently applying these
+principles to every aspect of managing this project. Project maintainers who do
+not follow or enforce the Code of Conduct may be permanently removed from the
+project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by opening an issue or contacting one or more of the project
+maintainers.
+
+This Code of Conduct is adapted from the
+{Contributor Covenant}[http://contributor-covenant.org], version 1.2.0,
+available at
+{http://contributor-covenant.org/version/1/2/0/}[http://contributor-covenant.org/version/1/2/0/].

data/History.rdoc

@@ -1,3 +1,33 @@
+=== 2.0 / 2015-10-19
+
+* 1 major enhancement
+
+  * Added Minitest::AssertionTests to assist with testing newly added
+    assertions, even for other gems. Previously, a variant of what is provided
+    was present in +test/minitest_config.rb+.
+
+* 2 minor enhancements
+
+  * Made the expectation +must_be_between+ ready for the next version of
+    Minitest by calling +assert_between+ on the test context (+ctx+) rather
+    than on the bare object under test. Because of this change,
+    minitest-bonus-assertions is now tested for compatibility only with
+    minitest 5.8 or higher.
+
+  * Added +assert_set_equal+ and +refute_set_equal+ (with expectation forms of
+    +must_equal_set+ and +must_not_equal_set+) to test enumerable values for
+    set equality.
+
+* 1 minor bugfix
+
+  * The documentation for +assert_between+ was unclear; it is a
+    boundary-exclusive test, not a boundary-inclusive test. That is, it is
+    <tt>lo &lt; exp &lt; hi</tt>, not <tt>lo &lt;= exp &lt;= hi</tt>.
+
+* 1 governance change
+
+  * This project now has a {Code of Conduct}[Code-of-Conduct_rdoc.html]
+
 === 1.0 / 2015-03-05
 
 * 1 major enhancement

data/Manifest.txt

@@ -4,6 +4,7 @@
 .minitest.rb
 .travis.yml
 .workenv
+Code-of-Conduct.rdoc
 Contributing.rdoc
 Gemfile
 History.rdoc
@@ -11,7 +12,7 @@ Licence.rdoc
 Manifest.txt
 README.rdoc
 Rakefile
-VERSION
 lib/minitest-bonus-assertions.rb
+lib/minitest/assertion_tests.rb
 test/minitest_config.rb
 test/test_minitest-bonus-assertions.rb

data/README.rdoc

@@ -6,41 +6,56 @@ continuous integration :: {<img src="https://travis-ci.org/halostatue/minitest-b
 
 == Description
 
-Additional assertions for {Minitest}[https://github.com/seattlerb/minitest].
+Bonus assertions for {Minitest}[https://github.com/seattlerb/minitest],
+providing assertions I use frequently.
 
 == Features
 
 New assertions:
 
-  assert_false, must_be_false
-  assert_true, must_Be_true
-  assert_between, must_be_between
-  assert_has_keys, must_have_keys
-  assert_missing_keys, must_not_have_keys
-  assert_raises_with_message, must_raise_with_message
+* +assert_false+: requires that the value be exactly +false+. (+must_be_false+)
+* +assert_true+: requires that the value be exactly +true+. (+must_be_true+)
+* +assert_between+: requires that the value be strictly between the low and
+  high values provided, or the range (this test is boundary-exclusive).
+  (+must_be_between+)
+* +assert_has_keys+/+refute_missing_keys+: requires that the object contains all
+  of the keys expected. (+must_have_keys+)
+* +assert_missing_keys+/+refute_has_keys+: requires that the object *not* have
+  any of the keys expected. (+must_not_have_keys+)
+* +assert_raises_with_message+: requires that the exception raised in the
+  provided block has a specific message (tested with +assert_equal+).
+  (+must_raise_with_message+)
+* +assert_set_equal+: requires that the actual enumerable have the same values
+  as the expected enumerable, without regard to order and ignoring duplicate
+  values. (+must_equal_set+)
+* +refute_set_equal+: requires that the actual enumerable *not* have the same
+  values as the expected enumerable. (+must_not_equal_set+)
+
+I am also providing the Minitest-tester code I use as something that can be
+required by other developers. This should *only* be used to test Minitest
+assertions and extensions. For more information on Minitest::AssertionTests,
+see its documentation.
 
 == Background
 
-minitest-bonus-assertions started life as a patch to the assertions provided by
-Ben Somer’s
+minitest-bonus-assertions started life as a patch to Ben Somer’s
 {minitest-extra-assertions}[https://github.com/bensomers/minitest-extra-assertions].
 There were some nice assertions included, but there were other changes that
 needed to be made to bring it up to support Minitest 5. There was also an
 override to the default +assert_match+ implementation meant to ease the
 transition from Test::Unit (the main reason he wrote this assertion plugin for
 Minitest in the first place). I do not believe this is sensible five major
-versions in: I removed it.
-
-Because Ben did not feel comfortable making this particular change, I felt that
-the best way to provide the original assertions and my new assertions—without
-the +assert_match+ override—was to fork this as a new project. I am indebted to
-Ben for writing these assertions in the first place.
+versions into Minitest: I removed it. Ben did not feel comfortable making this
+particular change, so I felt that the best way to provide the original
+assertions and my new assertions—without the +assert_match+ override—was to
+fork this as a new project. I am indebted to Ben and his contributors for
+writing these assertions in the first place.
 
 == Install
 
 Add it to your Gemfile:
 
-  gem 'minitest-bonus-assertions', '~> 1.0'
+  gem 'minitest-bonus-assertions', '~> 1.1'
 
 Or manually install:
 
@@ -53,6 +68,8 @@ scheme with one change:
 
 * When PATCH is zero (+0+), it will be omitted from version references.
 
+:include: Code-of-Conduct.rdoc
+
 :include: Contributing.rdoc
 
 :include: Licence.rdoc

data/Rakefile

@@ -16,7 +16,8 @@ spec = Hoe.spec 'minitest-bonus-assertions' do
 
   self.history_file = 'History.rdoc'
   self.readme_file = 'README.rdoc'
-  self.extra_rdoc_files = FileList["*.rdoc"].to_a
+  self.extra_rdoc_files = FileList["*.rdoc"].to_a -
+    %w(History.rdoc README.rdoc)
 
   license "MIT"
 
@@ -27,7 +28,7 @@ spec = Hoe.spec 'minitest-bonus-assertions' do
   self.extra_dev_deps << ['hoe-gemspec2', '~> 1.1']
   self.extra_dev_deps << ['hoe-git', '~> 1.5']
   self.extra_dev_deps << ['hoe-travis', '~> 1.2']
-  self.extra_dev_deps << ['minitest', '~> 5.4']
+  self.extra_dev_deps << ['minitest', '~> 5.8']
   self.extra_dev_deps << ['minitest-around', '~> 0.3']
   self.extra_dev_deps << ['minitest-autotest', '~> 1.0']
   self.extra_dev_deps << ['minitest-bisect', '~> 1.2']

data/lib/minitest-bonus-assertions.rb

@@ -1,7 +1,8 @@
 module Minitest
-  module BonusAssertions
-    VERSION = '1.0'
+  module BonusAssertions # :nodoc:
+    VERSION = '2.0' # :nodoc:
   end
+
   module Assertions
     ##
     # Fails unless +obj+ is literally +false+.
@@ -20,14 +21,23 @@ module Minitest
     end
 
     ##
-    # Fails unless +exp+ is between +lo+ and +hi+, or is in +range+.
+    # Fails unless +exp+ is between +lo+ and +hi+, or is in +range+. This test
+    # is exclusive of the boundaries. That is:
+    #
+    #   assert_between 1, 10, 1
+    #
+    # will return false, but:
+    #
+    #   assert_between 0.99, 10.1, 1
+    #
+    # will return true.
     #
     # :call-seq:
     #    assert_between lo, hi, exp, msg = nil
     #    assert_between range, exp, msg = nil
 
     def assert_between(*args)
-      lo, hi, exp, msg = if args.first.is_a?(Range)
+      lo, hi, exp, msg = if args.first.kind_of?(Range)
                            [args.first.begin, args.first.end, args[1], args[2]]
                          else
                            args[0..3]
@@ -39,8 +49,9 @@ module Minitest
 
     ##
     # Fails unless +obj+ has all of the +keys+ listed.
+
     def assert_has_keys obj, keys, msg = nil
-      keys = [ keys ] unless keys.is_a?(Array)
+      keys = [ keys ] unless keys.kind_of?(Array)
       msg = message(msg) { "Expected #{mu_pp(obj)} to include all keys #{mu_pp(keys)}" }
       keys.all? { |key| assert obj.key?(key), msg }
     end
@@ -48,9 +59,12 @@ module Minitest
 
     ##
     # Fails if +obj+ has any of the keys listed.
+
     def assert_missing_keys obj, keys, msg = nil
-      keys = [ keys ] unless keys.is_a?(Array)
-      msg = message(msg) { "Expected #{mu_pp(obj)} not to include any of these keys #{mu_pp(keys)}" }
+      keys = [ keys ] unless keys.kind_of?(Array)
+      msg = message(msg) {
+        "Expected #{mu_pp(obj)} not to include any of these keys #{mu_pp(keys)}"
+      }
       keys.none? { |key| refute obj.key?(key), msg }
     end
     alias_method :refute_has_keys, :assert_missing_keys
@@ -58,6 +72,7 @@ module Minitest
     ##
     # Fails unless the block raises +exp+ with the message +exp_msg+. Returns
     # the exception matched so you can check other attributes.
+
     def assert_raises_with_message exp, exp_msg, msg = nil
       msg = message(msg) { "#{mu_pp(exp)} exception expected with message #{mu_pp(exp_msg)}" }
 
@@ -68,6 +83,28 @@ module Minitest
       assert_equal exp_msg, exception.message, msg
       exception
     end
+
+    ##
+    # Fails unless the set from +actual+ matches the set from +exp+.
+
+    def assert_set_equal expected, actual, msg = nil
+      require 'set'
+      msg = message(msg) {
+        "Expected #{mu_pp(actual)} to be set equivalent to #{mu_pp(expected)}"
+      }
+      assert_equal Set.new(expected), Set.new(actual), msg
+    end
+
+    ##
+    # Fails unless the set from +actual+ differs from the set from +exp+.
+
+    def refute_set_equal expected, actual, msg = nil
+      require 'set'
+      msg = message(msg) {
+        "Expected #{mu_pp(actual)} not to be set equivalent to #{mu_pp(expected)}"
+      }
+      refute_equal Set.new(expected), Set.new(actual), msg
+    end
   end
 
   module Expectations
@@ -96,12 +133,12 @@ module Minitest
     #   2.must_be_between 1..3
 
     def must_be_between *args
-      hi, lo, msg  = if args.first.is_a?(Range)
+      hi, lo, msg  = if args.first.kind_of?(Range)
                        [args.first.begin, args.first.end, args[1]]
                      else
                        args[0..2]
                      end
-      assert_between lo, hi, self
+      ctx.assert_between lo, hi, target, msg
     end
 
     ##
@@ -130,5 +167,23 @@ module Minitest
     # :method: must_raise_with_message
 
     infect_an_assertion :assert_raises_with_message, :must_raise_with_message
+
+    ##
+    # See Minitest::Assertions#assert_set_equal
+    #
+    #    %w(a b c).must_equal_set %(c b a)
+    #
+    # :method: must_equal_set
+
+    infect_an_assertion :assert_set_equal, :must_equal_set, :unary
+
+    ##
+    # See Minitest::refuteions#refute_set_equal
+    #
+    #    %w(a b c).must_equal_set %(c b a)
+    #
+    # :method: must_equal_set
+
+    infect_an_assertion :refute_set_equal, :must_not_equal_set, :unary
   end
 end

data/lib/minitest/assertion_tests.rb

@@ -0,0 +1,56 @@
+##
+# Use Minitest::AssertionTests to test assertions for Minitest.
+#
+#   describe Minitest::BonusAssertions do
+#     include Minitest::AssertionTests
+#
+#     it 'be triggered for false or nil' do
+#       assert_expected_assertions 2 do
+#         assert_assertion_triggered '<true> expected but was false.' do
+#           tc.assert_true false
+#         end
+#
+#         assert_assertion_triggered '<true> expected but was nil.' do
+#           tc.assert_true nil
+#         end
+#       end
+#     end
+#   end
+module Minitest::AssertionTests
+  # The test case to use for the assertion under test.
+  attr_reader :tc
+  # The test spec to use for the expectation under test.
+  attr_reader :spec
+
+  def setup # :nodoc:
+    super
+
+    Minitest::Test.reset
+
+    @tc = Minitest::Test.new 'fake test case'
+    @spec = Minitest::Spec.new 'fake test spec'
+  end
+
+  # Specify the number of assertions that should be called during the test
+  # under this block. Most tests should be wrapped in this assertion.
+  def assert_expected_assertions expected = 1
+    yield
+  ensure
+    actual = tc.assertions + spec.assertions
+    assert_equal expected, actual, "expected #{expected} assertions to be " +
+      "fired during the test, not #{actual}"
+  end
+
+  # Specify that the assertion was expected to fail with the resulting message.
+  def assert_assertion_triggered expected, klass = Minitest::Assertion
+    e = assert_raises(klass) do
+      yield
+    end
+
+    msg = e.message.sub(/(---Backtrace---).*/m, '\1')
+    msg.gsub!(/\(oid=[-0-9]+\)/, '(oid=N)')
+    msg.gsub!(/(\d\.\d{6})\d+/, '\1xxx') # normalize: ruby version, impl, platform
+
+    assert_equal expected, msg
+  end
+end

data/test/minitest_config.rb

@@ -6,37 +6,4 @@ require 'minitest/moar'
 require 'minitest/bisect'
 
 require 'minitest-bonus-assertions'
-
-module Minitest::AssertionTester
-  def setup
-    super
-
-    Minitest::Test.reset
-
-    @tc = Minitest::Test.new 'fake tc'
-    @zomg = "zomg ponies!"
-    @assertion_count = 1
-  end
-
-  def teardown
-    if @tc.assertions
-      assert_equal @assertion_count, @tc.assertions,
-        "expected #{@assertion_count} assertions to be fired during the test, not #{@tc.assertions}"
-    end
-    Object.send(:remove_const, :ATestCase) if defined? ATestCase
-  end
-
-  def util_assert_triggered expected, klass = Minitest::Assertion
-    e = assert_raises(klass) do
-      yield
-    end
-
-    msg = e.message.sub(/(---Backtrace---).*/m, '\1')
-    msg.gsub!(/\(oid=[-0-9]+\)/, '(oid=N)')
-    msg.gsub!(/(\d\.\d{6})\d+/, '\1xxx') # normalize: ruby version, impl, platform
-
-    assert_equal expected, msg
-  end
-
-  Minitest::Test.send(:include, self)
-end
+require 'minitest/assertion_tests'

data/test/test_minitest-bonus-assertions.rb

@@ -3,160 +3,225 @@
 require 'minitest_config'
 
 describe Minitest::BonusAssertions do
-  describe ".assert_true" do
-    it "return true for true" do
-      @assertion_count = 1
+  include Minitest::AssertionTests
 
-      assert_equal true, @tc.assert_true(true), "returns true for true"
+  describe '.assert_true' do
+    it 'return true for true' do
+      assert_expected_assertions do
+        assert_equal true, tc.assert_true(true), 'returns true for true'
+      end
     end
 
-    it "be triggered for false or nil" do
-      @assertion_count = 2
+    it 'be triggered for false or nil' do
+      assert_expected_assertions 2 do
+        assert_assertion_triggered '<true> expected but was false.' do
+          tc.assert_true false
+        end
 
-      util_assert_triggered "<true> expected but was false." do
-        @tc.assert_true false
-      end
-      util_assert_triggered "<true> expected but was nil." do
-        @tc.assert_true nil
+        assert_assertion_triggered '<true> expected but was nil.' do
+          tc.assert_true nil
+        end
       end
     end
 
-    it "be triggered for things that aren't true but evaluate to true" do
-      @assertion_count = 1
-
-      util_assert_triggered "<true> expected but was Object." do
-        @tc.assert_true Object
+    it %q(be triggered for things that aren't true but evaluate to true) do
+      assert_expected_assertions do
+        assert_assertion_triggered '<true> expected but was Object.' do
+          tc.assert_true Object
+        end
       end
     end
   end
 
-  describe ".assert_false" do
-    it "return true for false" do
-      @assertion_count = 1
-
-      assert_equal true, @tc.assert_false(false), "returns true for false"
+  describe '.assert_false' do
+    it 'return true for false' do
+      assert_expected_assertions do
+        assert_equal true, tc.assert_false(false), 'returns true for false'
+      end
     end
 
-    it "be triggered for nil" do
-      @assertion_count = 1
+    it 'be triggered for nil' do
+      assert_expected_assertions do
+        assert_assertion_triggered '<false> expected but was nil.' do
+          tc.assert_false nil
+        end
+      end
+    end
 
-      util_assert_triggered "<false> expected but was nil." do
-        @tc.assert_false nil
+    it 'be triggered for things that evalute to true' do
+      assert_expected_assertions do
+        assert_assertion_triggered '<false> expected but was Object.' do
+          tc.assert_false Object
+        end
       end
     end
+  end
 
-    it "be triggered for things that evalute to true" do
-      @assertion_count = 1
+  describe '.assert_between' do
+    it 'return true for basic integers' do
+      assert_expected_assertions do
+        assert_equal true, tc.assert_between(1, 10, 5), 'returns true for 1 to 10 and 5'
+      end
+    end
 
-      util_assert_triggered "<false> expected but was Object." do
-        @tc.assert_false Object
+    it 'return true for the range case' do
+      assert_expected_assertions do
+        assert_equal true, tc.assert_between((1..10), 5), 'returns true for 1..10 with 5'
       end
     end
-  end
 
-  describe ".assert_between" do
-    it "return true for basic integers" do
-      @assertion_count = 1
-      assert_equal true, @tc.assert_between(1,10,5), "returns true for 1 to 10 and 5"
+    it 'handle the case where the hi part is first' do
+      assert_expected_assertions do
+        assert_equal true, tc.assert_between(10, 1, 5), 'returns true for 10 to 1, with 5'
+      end
     end
 
-    it "return true for the range case" do
-      @assertion_count = 1
-      assert_equal true, @tc.assert_between((1..10), 5), "returns true for 1..10 with 5"
+    it 'return false for values outside the bounds' do
+      assert_expected_assertions do
+        assert_assertion_triggered 'Expected 100 to be between 1 and 10.' do
+          tc.assert_between(1, 10, 100)
+        end
+      end
     end
 
-    it "handle the case where the hi part is first" do
-      @assertion_count = 1
-      assert_equal true, @tc.assert_between(10, 1, 5), "returns true for 10 to 1, with 5"
+    it 'returns false for values strictly on the bounds' do
+      assert_expected_assertions do
+        assert_assertion_triggered 'Expected 1 to be between 1 and 10.' do
+          tc.assert_between(1, 10, 1)
+        end
+      end
     end
 
-    it "return false for values outside the bounds" do
-      @assertion_count = 1
-      util_assert_triggered "Expected 100 to be between 1 and 10." do
-        @tc.assert_between(1, 10, 100)
+    it 'raise error for incompatible values' do
+      assert_expected_assertions 0 do
+        assert_raises ArgumentError do
+          tc.assert_between(1, 10, Time.now)
+        end
       end
     end
 
-    it "raise error for incompatible values" do
-      @assertion_count = 0
-      assert_raises ArgumentError do
-        @tc.assert_between(1, 10, Time.now)
+    it 'works correctly with the new expectation format' do
+      assert_expected_assertions do
+        assert_equal true, spec._(5).must_be_between(1, 10)
       end
     end
   end
 
-  describe ".assert_has_keys" do
-    it "return true if the keys are present" do
-      @assertion_count = 1
-      assert_equal true, @tc.assert_has_keys({ "a" => 1 }, "a"), %Q(returns true for key 'a' in {"a"=>1})
+  describe '.assert_has_keys' do
+    it 'return true if the keys are present' do
+      assert_expected_assertions do
+        assert_equal true, tc.assert_has_keys({ 'a' => 1 }, 'a'),
+          %q(returns true for key 'a' in { 'a' => 1 })
+      end
     end
 
-    it "be triggered for a missing value" do
-      @assertion_count = 2
-      hash = { "a" => 1 }
+    it 'be triggered for a missing value' do
+      hash = { 'a' => 1 }
       keys = %w(a b)
-      util_assert_triggered %Q(Expected #{mu_pp(hash)} to include all keys #{mu_pp(keys)}.) do
-        @tc.assert_has_keys(hash, keys)
+      assert_expected_assertions 2 do
+        assert_assertion_triggered %Q(Expected #{mu_pp(hash)} to include all keys #{mu_pp(keys)}.) do
+          tc.assert_has_keys(hash, keys)
+        end
       end
     end
 
-    it "raise error for incompatible values" do
-      @assertion_count = 0
-      assert_raises NoMethodError do
-        @tc.assert_has_keys([], "a")
+    it 'raise error for incompatible values' do
+      assert_expected_assertions 0 do
+        assert_raises NoMethodError do
+          tc.assert_has_keys([], 'a')
+        end
       end
     end
   end
 
-  describe ".assert_missing_keys" do
-    it "return true if the keys are missing" do
-      @assertion_count = 1
-      assert_equal true, @tc.assert_missing_keys({ "a" => 1 }, "b"), "returns true for key 'b' missing from { 'a' => 1 }"
+  describe '.assert_missing_keys' do
+    it 'return true if the keys are missing' do
+      assert_expected_assertions do
+        assert_equal true, tc.assert_missing_keys({ 'a' => 1 }, 'b'),
+          %q(returns true for key 'b' missing from { 'a' => 1 })
+      end
     end
 
-    it "be triggered for a present value" do
-      @assertion_count = 1
-      hash = { "a" => 1 }
+    it 'be triggered for a present value' do
+      hash = { 'a' => 1 }
       keys = %w(a b)
-      util_assert_triggered %Q(Expected #{mu_pp(hash)} not to include any of these keys #{mu_pp(keys)}.) do
-        @tc.assert_missing_keys(hash, keys)
+      assert_expected_assertions do
+        assert_assertion_triggered %Q(Expected #{mu_pp(hash)} not to include any of these keys #{mu_pp(keys)}.) do
+          tc.assert_missing_keys(hash, keys)
+        end
       end
     end
 
-    it "raise error for incompatible values" do
-      @assertion_count = 0
-      assert_raises NoMethodError do
-        @tc.assert_missing_keys([], "a")
+    it 'raise error for incompatible values' do
+      assert_expected_assertions 0 do
+        assert_raises NoMethodError do
+          tc.assert_missing_keys([], 'a')
+        end
       end
     end
   end
 
-  describe ".assert_raises_with_message" do
-    it "return the matched exception if the exception and message match" do
-      @assertion_count = 2
+  describe '.assert_raises_with_message' do
+    it 'return the matched exception if the exception and message match' do
+      assert_expected_assertions 2 do
+        res = tc.assert_raises_with_message(ArgumentError, %q(Don't have a cow, man!)) do
+          raise ArgumentError, %q(Don't have a cow, man!)
+        end
 
-      res = @tc.assert_raises_with_message(ArgumentError, "Don't have a cow, man!") do
-        raise ArgumentError, "Don't have a cow, man!"
+        assert_kind_of ArgumentError, res
       end
+    end
 
-      assert_kind_of ArgumentError, res
+    it 'is triggered with a different exception' do
+      assert_expected_assertions do
+        assert_assertion_triggered %Q(#{mu_pp([ArgumentError])} exception expected, not\nClass: <NoMethodError>\nMessage: <"NoMethodError">\n---Backtrace---) do
+          tc.assert_raises_with_message(ArgumentError, 'Don’t have a cow, man!') do
+            raise NoMethodError
+          end
+        end
+      end
     end
 
-    it "is triggered with a different exception" do
-      @assertion_count = 1
+    it 'be triggered with a different message' do
+      assert_expected_assertions 2 do
+        assert_assertion_triggered %Q(ArgumentError exception expected with message "Don’t have a cow, man!".\nExpected: "Don’t have a cow, man!"\n  Actual: "Have a cow, man!") do
+          tc.assert_raises_with_message(ArgumentError, 'Don’t have a cow, man!') do
+            raise ArgumentError, 'Have a cow, man!'
+          end
+        end
+      end
+    end
+  end
+
+  describe '.assert_set_equal' do
+    it 'return true if the sets are equal' do
+      assert_expected_assertions do
+        assert_equal true, tc.assert_set_equal(%w(a b c), %w(c b a)),
+          %q(returns true for sets %w(a b c) and %w(c b a))
+      end
+    end
 
-      util_assert_triggered %Q(#{mu_pp([ArgumentError])} exception expected, not\nClass: <NoMethodError>\nMessage: <"NoMethodError">\n---Backtrace---) do
-        @tc.assert_raises_with_message(ArgumentError, "Don’t have a cow, man!") do
-          raise NoMethodError
+    it 'is triggered if they are not equal' do
+      assert_expected_assertions do
+        assert_assertion_triggered %Q(Expected [\n  \"c\",\n  \"b\"\n] to be set equivalent to [\n  \"a\",\n  \"b\",\n  \"c\"\n].\nExpected: #<Set: {\"a\", \"b\", \"c\"}>\n  Actual: #<Set: {\"c\", \"b\"}>) do
+          tc.assert_set_equal %w(a b c), %w(c b)
         end
       end
     end
+  end
+
+  describe '.refute_set_equal' do
+    it 'return true if the sets are not equal' do
+      assert_expected_assertions do
+        assert_equal false, tc.refute_set_equal(%w(a b c), %w(c b)),
+          %q(returns true for sets %w(a b c) and %w(c b))
+      end
+    end
 
-    it "be triggered with a different message" do
-      @assertion_count = 2
-      util_assert_triggered %Q(ArgumentError exception expected with message "Don’t have a cow, man!".\nExpected: "Don’t have a cow, man!"\n  Actual: "Have a cow, man!") do
-        @tc.assert_raises_with_message(ArgumentError, "Don’t have a cow, man!") do
-          raise ArgumentError, "Have a cow, man!"
+    it 'is triggered if they are not equal' do
+      assert_expected_assertions do
+        assert_assertion_triggered %Q(Expected [\n  \"c\",\n  \"b\",\n  \"a\"\n] not to be set equivalent to [\n  \"a\",\n  \"b\",\n  \"c\"\n].\nExpected #<Set: {\"c\", \"b\", \"a\"}> to not be equal to #<Set: {\"a\", \"b\", \"c\"}>.) do
+          tc.refute_set_equal %w(a b c), %w(c b a)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-bonus-assertions
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: '2.0'
 platform: ruby
 authors:
 - Austin Ziegler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-05 00:00:00.000000000 Z
+date: 2015-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.5'
+        version: '5.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.5'
+        version: '5.8'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -212,20 +212,23 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.13'
+        version: '3.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.13'
-description: Additional assertions for {Minitest}[https://github.com/seattlerb/minitest].
+        version: '3.14'
+description: |-
+  Bonus assertions for {Minitest}[https://github.com/seattlerb/minitest],
+  providing assertions I use frequently.
 email:
 - halostatue@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
+- Code-of-Conduct.rdoc
 - Contributing.rdoc
 - History.rdoc
 - Licence.rdoc
@@ -238,6 +241,7 @@ files:
 - ".minitest.rb"
 - ".travis.yml"
 - ".workenv"
+- Code-of-Conduct.rdoc
 - Contributing.rdoc
 - Gemfile
 - History.rdoc
@@ -245,8 +249,8 @@ files:
 - Manifest.txt
 - README.rdoc
 - Rakefile
-- VERSION
 - lib/minitest-bonus-assertions.rb
+- lib/minitest/assertion_tests.rb
 - test/minitest_config.rb
 - test/test_minitest-bonus-assertions.rb
 homepage: https://github.com/halostatue/minitest-bonus-assertions
@@ -271,8 +275,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
-summary: Additional assertions for {Minitest}[https://github.com/seattlerb/minitest].
+summary: Bonus assertions for {Minitest}[https://github.com/seattlerb/minitest], providing
+  assertions I use frequently.
 test_files: []

data/VERSION

@@ -1 +0,0 @@
-0.2.0