assert 2.17.0 → 2.18.4

data/test/unit/utils_tests.rb

@@ -5,61 +5,58 @@ require "tempfile"
 require "assert/config"
 
 module Assert::Utils
-
   class UnitTests < Assert::Context
     desc "Assert::Utils"
-    subject{ Assert::Utils }
-    setup do
-      @objs = [1, "hi there", Hash.new, [:a, :b]]
-    end
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Utils }
+
+    let(:objs1) { [1, "hi there", Hash.new, [:a, :b]] }
 
     should have_imeths :show, :show_for_diff
     should have_imeths :tempfile
     should have_imeths :stdlib_pp_proc, :default_use_diff_proc, :syscmd_diff_proc
     should have_imeths :git_changed_proc
-
   end
 
   class ShowTests < UnitTests
     desc "`show`"
-    setup do
-      @pp_config = Assert::Config.new({
+
+    let(:pp_config1) {
+      Assert::Config.new({
         :pp_objects => true,
         :pp_proc => Proc.new{ |input| "herp derp" }
       })
-    end
+    }
 
     should "use `inspect` to show objs when `pp_objects` setting is false" do
-      @objs.each do |obj|
-        assert_equal obj.inspect, subject.show(obj, Factory.modes_off_config)
+      objs1.each do |obj|
+        assert_that(subject.show(obj, Factory.modes_off_config)).equals(obj.inspect)
       end
     end
 
     should "use `pp_proc` to show objs when `pp_objects` setting is true" do
-      @objs.each do |obj|
-        assert_equal @pp_config.pp_proc.call(obj), subject.show(obj, @pp_config)
+      objs1.each do |obj|
+        assert_that(subject.show(obj, pp_config1)).equals(pp_config1.pp_proc.call(obj))
       end
     end
-
   end
 
   class ShowForDiffTests < ShowTests
     desc "`show_for_diff`"
-    setup do
-      @w_newlines = { :string => "herp derp, derp herp\nherpderpedia" }
-      @w_obj_id = Class.new.new
-    end
+
+    let(:w_newlines1) { { :string => "herp derp, derp herp\nherpderpedia" } }
+    let(:w_obj_id1) { Class.new.new }
 
     should "call show, escaping newlines" do
       exp_out = "{:string=>\"herp derp, derp herp\nherpderpedia\"}"
-      assert_equal exp_out, subject.show_for_diff(@w_newlines, Factory.modes_off_config)
+      assert_that(subject.show_for_diff(w_newlines1, Factory.modes_off_config)).equals(exp_out)
     end
 
     should "make any obj ids generic" do
       exp_out = "#<#<Class:0xXXXXXX>:0xXXXXXX>"
-      assert_equal exp_out, subject.show_for_diff(@w_obj_id, Factory.modes_off_config)
+      assert_that(subject.show_for_diff(w_obj_id1, Factory.modes_off_config)).equals(exp_out)
     end
-
   end
 
   class TempfileTests < UnitTests
@@ -67,82 +64,74 @@ module Assert::Utils
 
     should "require tempfile, open a tempfile, write the given content, and yield it" do
       subject.tempfile("a-name", "some-content") do |tmpfile|
-        assert_equal false, (require "tempfile")
+        assert_that((require "tempfile")).equals(false)
         assert tmpfile
-        assert_kind_of Tempfile, tmpfile
+        assert_that(tmpfile).is_kind_of(Tempfile)
 
         tmpfile.pos = 0
-        assert_equal "some-content\n", tmpfile.read
+        assert_that(tmpfile.read).equals("some-content\n")
       end
     end
-
   end
 
   class StdlibPpProcTests < UnitTests
     desc "`stdlib_pp_proc`"
 
     should "build a pp proc that uses stdlib `PP.pp` to pretty print objects" do
-      exp_obj_pps = @objs.map{ |o| PP.pp(o, "", 79).strip }
-      act_obj_pps = @objs.map{ |o| subject.stdlib_pp_proc.call(o) }
-      assert_equal exp_obj_pps, act_obj_pps
+      exp_obj_pps = objs1.map{ |o| PP.pp(o, "", 79).strip }
+      act_obj_pps = objs1.map{ |o| subject.stdlib_pp_proc.call(o) }
+      assert_that(act_obj_pps).equals(exp_obj_pps)
 
       cust_width = 1
-      exp_obj_pps = @objs.map{ |o| PP.pp(o, "", cust_width).strip }
-      act_obj_pps = @objs.map{ |o| subject.stdlib_pp_proc(cust_width).call(o) }
-      assert_equal exp_obj_pps, act_obj_pps
+      exp_obj_pps = objs1.map{ |o| PP.pp(o, "", cust_width).strip }
+      act_obj_pps = objs1.map{ |o| subject.stdlib_pp_proc(cust_width).call(o) }
+      assert_that(act_obj_pps).equals(exp_obj_pps)
     end
-
   end
 
   class DefaultUseDiffProcTests < UnitTests
     desc "`default_use_diff_proc`"
-    setup do
-      @longer = "i am a really long string output; use diff when working with me"
-      @newlines = "i have\n newlines"
-    end
+
+    let(:longer1)   { "i am a really long string output; use diff when working with me" }
+    let(:newlines1) { "i have\n newlines" }
 
     should "be true if either output has newlines or is bigger than 29 chars" do
       proc = subject.default_use_diff_proc
 
       assert_not proc.call("", "")
-      assert proc.call(@longer, "")
-      assert proc.call(@newlines, "")
-      assert proc.call("", @longer)
-      assert proc.call("", @newlines)
-      assert proc.call(@longer, @newlines)
+      assert proc.call(longer1, "")
+      assert proc.call(newlines1, "")
+      assert proc.call("", longer1)
+      assert proc.call("", newlines1)
+      assert proc.call(longer1, newlines1)
     end
-
   end
 
   class SyscmdDiffProc < UnitTests
     desc "`syscmd_diff_proc`"
-    setup do
-      @diff_a_file = File.join(ROOT_PATH, "test/support/diff_a.txt")
-      @diff_b_file = File.join(ROOT_PATH, "test/support/diff_b.txt")
 
-      @diff_a = File.read(@diff_a_file)
-      @diff_b = File.read(@diff_b_file)
-    end
+    let(:diff_a_file1) { File.join(ROOT_PATH, "test/support/diff_a.txt") }
+    let(:diff_b_file1) { File.join(ROOT_PATH, "test/support/diff_b.txt") }
+    let(:diff_a1)      { File.read(diff_a_file1) }
+    let(:diff_b1)      { File.read(diff_b_file1) }
 
     should "use the diff syscmd to output the diff between the exp/act show output" do
-      exp_diff_out = `diff --unified=-1 #{@diff_a_file} #{@diff_b_file}`.strip.tap do |out|
+      exp_diff_out = `diff --unified=-1 #{diff_a_file1} #{diff_b_file1}`.strip.tap do |out|
         out.sub!(/^\-\-\- .+/, "--- expected")
         out.sub!(/^\+\+\+ .+/, "+++ actual")
       end
 
-      assert_equal exp_diff_out, subject.syscmd_diff_proc.call(@diff_a, @diff_b)
+      assert_that(subject.syscmd_diff_proc.call(diff_a1, diff_b1)).equals(exp_diff_out)
     end
 
     should "allow you to specify a custom syscmd" do
       cust_syscmd = "diff"
-      exp_diff_out = `#{cust_syscmd} #{@diff_a_file} #{@diff_b_file}`.strip.tap do |out|
+      exp_diff_out = `#{cust_syscmd} #{diff_a_file1} #{diff_b_file1}`.strip.tap do |out|
         out.sub!(/^\-\-\- .+/, "--- expected")
         out.sub!(/^\+\+\+ .+/, "+++ actual")
       end
 
-      assert_equal exp_diff_out, subject.syscmd_diff_proc(cust_syscmd).call(@diff_a, @diff_b)
+      assert_that(subject.syscmd_diff_proc(cust_syscmd).call(diff_a1, diff_b1)).equals(exp_diff_out)
     end
-
   end
-
 end

data/test/unit/view_helpers_tests.rb

@@ -8,12 +8,13 @@ require "assert/result"
 require "assert/view"
 
 module Assert::ViewHelpers
-
   class UnitTests < Assert::Context
     desc "Assert::ViewHelpers"
-    setup do
-      test_opt_val = @test_opt_val = Factory.string
-      @helpers_class = Class.new do
+    subject { unit_class }
+
+    let(:unit_class) {
+      test_opt_val = test_opt_val1
+      Class.new do
         include Assert::ViewHelpers
 
         option "test_opt", test_opt_val
@@ -24,36 +25,33 @@ module Assert::ViewHelpers
           @config ||= [Assert.config, Assert::Config.new].sample
         end
       end
-    end
-    subject{ @helpers_class }
+    }
+
+    let(:test_opt_val1) { Factory.string }
 
     should have_imeths :option
 
     should "include the config helpers" do
-      assert_includes Assert::ConfigHelpers, subject
+      assert_that(subject).includes(Assert::ConfigHelpers)
     end
 
     should "write option values" do
-      helpers = @helpers_class.new
-      assert_equal @test_opt_val, helpers.test_opt
+      helpers = unit_class.new
+      assert_that(helpers.test_opt).equals(test_opt_val1)
 
       new_val = Factory.integer
       helpers.test_opt new_val
-      assert_equal new_val, helpers.test_opt
+      assert_that(helpers.test_opt).equals(new_val)
 
       other_val = Factory.integer
       helpers.test_opt new_val, other_val
-      assert_equal [new_val, other_val], helpers.test_opt
+      assert_that(helpers.test_opt).equals([new_val, other_val])
     end
-
   end
 
   class InitTests < UnitTests
     desc "when init"
-    setup do
-      @helpers = @helpers_class.new
-    end
-    subject{ @helpers }
+    subject { unit_class.new }
 
     should have_imeths :captured_output, :re_run_test_cmd
     should have_imeths :tests_to_run_count_statement, :result_count_statement
@@ -63,109 +61,109 @@ module Assert::ViewHelpers
 
     should "know how to build captured output" do
       output = Factory.string
-      exp = "--- stdout ---\n"\
-            "#{output}"\
-            "--------------"
-      assert_equal exp, subject.captured_output(output)
+      exp =
+        "--- stdout ---\n"\
+        "#{output}"\
+        "--------------"
+      assert_that(subject.captured_output(output)).equals(exp)
     end
 
     should "know how to build the re-run test cmd" do
       test_id = "#{Dir.pwd}/#{Factory.string}_tests.rb:#{Factory.integer}"
       exp = "assert -t #{test_id.gsub(Dir.pwd, ".")}"
-      assert_equal exp, subject.re_run_test_cmd(test_id)
+      assert_that(subject.re_run_test_cmd(test_id)).equals(exp)
     end
 
     should "know its tests-to-run count and result count statements" do
       exp = "#{subject.tests_to_run_count} test#{"s" if subject.tests_to_run_count != 1}"
-      assert_equal exp, subject.tests_to_run_count_statement
+      assert_that(subject.tests_to_run_count_statement).equals(exp)
 
       exp = "#{subject.result_count} result#{"s" if subject.result_count != 1}"
-      assert_equal exp, subject.result_count_statement
+      assert_that(subject.result_count_statement).equals(exp)
     end
 
     should "know how to build a sentence from a list of items" do
       items = 1.times.map{ Factory.string }
-      assert_equal items.first, subject.to_sentence(items)
+      assert_that(subject.to_sentence(items)).equals(items.first)
 
       items = 2.times.map{ Factory.string }
-      assert_equal items.join(" and "), subject.to_sentence(items)
+      assert_that(subject.to_sentence(items)).equals(items.join(" and "))
 
       items = (Factory.integer(3)+2).times.map{ Factory.string }
       exp = [items[0..-2].join(", "), items.last].join(", and ")
-      assert_equal exp, subject.to_sentence(items)
+      assert_that(subject.to_sentence(items)).equals(exp)
     end
 
     should "know its all pass result summary message" do
       Assert.stub(subject, :result_count){ 0 }
-      assert_equal "uhh...", subject.all_pass_result_summary_msg
+      assert_that(subject.all_pass_result_summary_msg).equals("uhh...")
 
       Assert.stub(subject, :result_count){ 1 }
-      assert_equal "pass", subject.all_pass_result_summary_msg
+      assert_that(subject.all_pass_result_summary_msg).equals("pass")
 
       Assert.stub(subject, :result_count){ Factory.integer(10)+1 }
-      assert_equal "all pass", subject.all_pass_result_summary_msg
+      assert_that(subject.all_pass_result_summary_msg).equals("all pass")
     end
 
     should "know its result summary msg" do
       res_type = :pass
       Assert.stub(subject, :all_pass?){ true }
       exp = subject.all_pass_result_summary_msg
-      assert_equal exp, subject.result_summary_msg(res_type)
+      assert_that(subject.result_summary_msg(res_type)).equals(exp)
 
       Assert.stub(subject, :all_pass?){ false }
       res_type = [:pass, :ignore, :fail, :skip, :error].sample
       exp = "#{subject.send("#{res_type}_result_count")} #{res_type.to_s}"
-      assert_equal exp, subject.result_summary_msg(res_type)
+      assert_that(subject.result_summary_msg(res_type)).equals(exp)
     end
 
     should "know its results summary sentence" do
-      items = subject.ocurring_result_types.map do |result_sym|
-        subject.result_summary_msg(result_sym)
-      end
+      items =
+        subject.ocurring_result_types.map do |result_sym|
+          subject.result_summary_msg(result_sym)
+        end
       exp = subject.to_sentence(items)
-      assert_equal exp, subject.results_summary_sentence
+      assert_that(subject.results_summary_sentence).equals(exp)
 
       block = proc{ |summary, result| "#{summary}--#{result}" }
-      items = subject.ocurring_result_types.map do |result_sym|
-        block.call(subject.result_summary_msg(result_sym), result_sym)
-      end
+      items =
+        subject.ocurring_result_types.map do |result_sym|
+          block.call(subject.result_summary_msg(result_sym), result_sym)
+        end
       exp = subject.to_sentence(items)
-      assert_equal exp, subject.results_summary_sentence(&block)
+      assert_that(subject.results_summary_sentence(&block)).equals(exp)
     end
-
   end
 
   class AnsiTests < UnitTests
     desc "Ansi"
-    subject{ Ansi }
+    subject { Ansi }
 
     should have_imeths :code_for
 
     should "know its codes" do
-      assert_not_empty subject::CODES
+      assert_that(subject::CODES).is_not_empty
     end
 
     should "map its code style names to ansi code strings" do
       styles = Factory.integer(3).times.map{ subject::CODES.keys.sample }
       exp = styles.map{ |n| "\e[#{subject::CODES[n]}m" }.join("")
-      assert_equal exp, subject.code_for(*styles)
+      assert_that(subject.code_for(*styles)).equals(exp)
 
       styles = Factory.integer(3).times.map{ Factory.string }
-      assert_equal "", subject.code_for(*styles)
+      assert_that(subject.code_for(*styles)).equals("")
 
       styles = []
-      assert_equal "", subject.code_for(*styles)
+      assert_that(subject.code_for(*styles)).equals("")
     end
-
   end
 
   class AnsiInitTests < UnitTests
     desc "when mixed in on a view"
-    setup do
-      view_class = Class.new(Assert::View){ include Ansi }
-      @view = view_class.new(Factory.modes_off_config, StringIO.new("", "w+"))
-    end
-    subject{ @view }
+    subject { view1 }
+
+    let(:view_class1) { Class.new(Assert::View){ include Ansi } }
+    let(:view1) { view_class1.new(Factory.modes_off_config, StringIO.new("", "w+")) }
 
     should have_imeths :ansi_styled_msg
 
@@ -175,28 +173,26 @@ module Assert::ViewHelpers
 
       Assert.stub(subject, :is_tty?){ false }
       Assert.stub(subject, :styled){ false }
-      assert_equal msg, subject.ansi_styled_msg(msg, result_type)
+      assert_that(subject.ansi_styled_msg(msg, result_type)).equals(msg)
 
       Assert.stub(subject, :is_tty?){ false }
       Assert.stub(subject, :styled){ true }
-      assert_equal msg, subject.ansi_styled_msg(msg, result_type)
+      assert_that(subject.ansi_styled_msg(msg, result_type)).equals(msg)
 
       Assert.stub(subject, :is_tty?){ true }
       Assert.stub(subject, :styled){ false }
-      assert_equal msg, subject.ansi_styled_msg(msg, result_type)
+      assert_that(subject.ansi_styled_msg(msg, result_type)).equals(msg)
 
       Assert.stub(subject, :is_tty?){ true }
       Assert.stub(subject, :styled){ true }
       Assert.stub(subject, "#{result_type}_styles"){ [] }
-      assert_equal msg, subject.ansi_styled_msg(msg, result_type)
+      assert_that(subject.ansi_styled_msg(msg, result_type)).equals(msg)
 
       styles = Factory.integer(3).times.map{ Assert::ViewHelpers::Ansi::CODES.keys.sample }
       Assert.stub(subject, "#{result_type}_styles"){ styles }
       exp_code = Assert::ViewHelpers::Ansi.code_for(*styles)
       exp = exp_code + msg + Assert::ViewHelpers::Ansi.code_for(:reset)
-      assert_equal exp, subject.ansi_styled_msg(msg, result_type)
+      assert_that(subject.ansi_styled_msg(msg, result_type)).equals(exp)
     end
-
   end
-
 end

data/test/unit/view_tests.rb

@@ -7,32 +7,29 @@ require "assert/suite"
 require "assert/view_helpers"
 
 class Assert::View
-
   class UnitTests < Assert::Context
     desc "Assert::View"
-    subject { Assert::View }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::View }
 
     should have_instance_method :require_user_view
 
     should "include the config helpers" do
-      assert_includes Assert::ConfigHelpers, subject
+      assert_that(subject).includes(Assert::ConfigHelpers)
     end
 
     should "include the view helpers" do
-      assert_includes Assert::ViewHelpers, subject
+      assert_that(subject).includes(Assert::ViewHelpers)
     end
-
   end
 
   class InitTests < UnitTests
     desc "when init"
-    setup do
-      @io     = StringIO.new("", "w+")
-      @config = Factory.modes_off_config
+    subject { Assert::View.new(config1, io1) }
 
-      @view = Assert::View.new(@config, @io)
-    end
-    subject{ @view }
+    let(:io1)     { StringIO.new("", "w+") }
+    let(:config1) { Factory.modes_off_config }
 
     should have_readers :config
     should have_imeths :view, :is_tty?
@@ -41,35 +38,33 @@ class Assert::View
     should have_imeths :before_test, :after_test, :on_result
 
     should "default its style options" do
-      assert_false subject.styled
+      assert_that(subject.styled).is_false
 
-      assert_nil subject.pass_styles
-      assert_nil subject.fail_styles
-      assert_nil subject.error_styles
-      assert_nil subject.skip_styles
-      assert_nil subject.ignore_styles
+      assert_that(subject.pass_styles).is_nil
+      assert_that(subject.fail_styles).is_nil
+      assert_that(subject.error_styles).is_nil
+      assert_that(subject.skip_styles).is_nil
+      assert_that(subject.ignore_styles).is_nil
     end
 
     should "default its result abbreviations" do
-      assert_equal ".", subject.pass_abbrev
-      assert_equal "F", subject.fail_abbrev
-      assert_equal "I", subject.ignore_abbrev
-      assert_equal "S", subject.skip_abbrev
-      assert_equal "E", subject.error_abbrev
+      assert_that(subject.pass_abbrev).equals(".")
+      assert_that(subject.fail_abbrev).equals("F")
+      assert_that(subject.ignore_abbrev).equals("I")
+      assert_that(subject.skip_abbrev).equals("S")
+      assert_that(subject.error_abbrev).equals("E")
     end
 
     should "know its config" do
-      assert_equal @config, subject.config
+      assert_that(subject.config).equals(config1)
     end
 
     should "override the config helper's view value with itself" do
-      assert_equal subject, subject.view
+      assert_that(subject.view).equals(subject)
     end
 
     should "know if it is a tty" do
-      assert_equal !!@io.isatty, subject.is_tty?
+      assert_that(subject.is_tty?).equals(!!io1.isatty)
     end
-
   end
-
 end