assert 2.18.2 → 2.18.3

data/test/unit/context/let_dsl_tests.rb

@@ -0,0 +1,10 @@
+require "assert"
+require "assert/context/let_dsl"
+
+module Assert::Context::LetDSL
+  class UnitTests < Assert::Context
+    desc "Assert::Context::LetDSL"
+
+    # This is tested implicitly by running Assert's test suite.
+  end
+end

data/test/unit/context/setup_dsl_tests.rb

@@ -4,77 +4,65 @@ require "assert/context/setup_dsl"
 module Assert::Context::SetupDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::SetupDSL"
-    subject{ @context_class }
+    subject { context_class1 }
+
+    let(:block1) { ::Proc.new {} }
+    let(:context_class1) { Factory.modes_off_context_class }
   end
 
   class SetupTeardownOnceMethodsTests < UnitTests
     desc "once methods"
-    setup do
-      block = @block = ::Proc.new{ something_once = true }
-      @context_class = Factory.modes_off_context_class do
-        setup_once(&block)
-        teardown_once(&block)
-      end
-    end
 
     should "add the block to the suite" do
-      assert_includes @block, subject.suite.send(:setups)
-      assert_includes @block, subject.suite.send(:teardowns)
+      subject.setup_once(&block1)
+      subject.teardown_once(&block1)
+
+      assert_that(subject.suite.send(:setups)).includes(block1)
+      assert_that(subject.suite.send(:teardowns)).includes(block1)
     end
   end
 
   class SetupTeardownMethodsTests < UnitTests
     desc "methods"
-    setup do
-      block = @block = ::Proc.new{ something = true }
-      @context_class = Factory.modes_off_context_class do
-        setup(&block)
-        teardown(&block)
-      end
-    end
 
     should "add the block to the context" do
-      assert_includes @block, subject.send(:setups)
-      assert_includes @block, subject.send(:teardowns)
+      subject.setup(&block1)
+      subject.teardown(&block1)
+
+      assert_that(subject.send(:setups)).includes(block1)
+      assert_that(subject.send(:teardowns)).includes(block1)
     end
   end
 
   class SetupTeardownWithMethodNameTests < UnitTests
     desc "methods given a method name"
-    setup do
-      method_name = @method_name = :something_amazing
-      @context_class = Factory.modes_off_context_class do
-        setup(method_name)
-        teardown(method_name)
-      end
-    end
+
+    let(:method_name1) { :something_amazing }
 
     should "add the method name to the context" do
-      assert_includes @method_name, subject.send(:setups)
-      assert_includes @method_name, subject.send(:teardowns)
+      subject.setup(method_name1)
+      subject.teardown(method_name1)
+
+      assert_that(subject.send(:setups)).includes(method_name1)
+      assert_that(subject.send(:teardowns)).includes(method_name1)
     end
   end
 
-  class SetupTeardownMultipleTests < UnitTests
+  class ParentContextClassTests < UnitTests
+    let(:parent_class1)  { Factory.modes_off_context_class }
+    let(:context_class1) { Factory.modes_off_context_class(parent_class1) }
+  end
+
+  class SetupTeardownMultipleTests < ParentContextClassTests
     desc "with multiple calls"
-    setup do
-      parent_setup_block    = ::Proc.new{ self.setup_status    =  "the setup"    }
-      parent_teardown_block = ::Proc.new{ self.teardown_status += "the teardown" }
-      @parent_class = Factory.modes_off_context_class do
-        setup(&parent_setup_block)
-        teardown(&parent_teardown_block)
-      end
 
-      context_setup_block    = ::Proc.new{ self.setup_status    += " has been run" }
-      context_teardown_block = ::Proc.new{ self.teardown_status += "has been run " }
-      @context_class = Factory.modes_off_context_class(@parent_class) do
-        setup(&context_setup_block)
-        setup(:setup_something)
-        teardown(:teardown_something)
-        teardown(&context_teardown_block)
-      end
+    let(:parent_setup_block1)     { ::Proc.new { self.setup_status     = "the setup"     } }
+    let(:parent_teardown_block1)  { ::Proc.new { self.teardown_status += "the teardown"  } }
+    let(:context_setup_block1)    { ::Proc.new { self.setup_status    += " has been run" } }
+    let(:context_teardown_block1) { ::Proc.new { self.teardown_status += "has been run " } }
 
-      @test_status_class = Class.new do
+    let(:test_status_class) {
+      Class.new do
         attr_accessor :setup_status, :teardown_status
         define_method(:setup_something) do
           self.setup_status += " with something"
@@ -83,57 +71,58 @@ module Assert::Context::SetupDSL
           self.teardown_status = "with something "
         end
       end
-    end
+    }
+
+    should "run its parent and its own blocks in the correct order" do
+      parent_class1.setup(&parent_setup_block1)
+      parent_class1.teardown(&parent_teardown_block1)
+      subject.setup(&context_setup_block1)
+      subject.setup(:setup_something)
+      subject.teardown(:teardown_something)
+      subject.teardown(&context_teardown_block1)
 
-    should "run it's parent and it's own blocks in the correct order" do
-      subject.send("run_setups", obj = @test_status_class.new)
-      assert_equal "the setup has been run with something", obj.setup_status
+      subject.send("run_setups", obj = test_status_class.new)
+      assert_that(obj.setup_status).equals("the setup has been run with something")
 
-      subject.send("run_teardowns", obj = @test_status_class.new)
-      assert_equal "with something has been run the teardown", obj.teardown_status
+      subject.send("run_teardowns", obj = test_status_class.new)
+      assert_that(obj.teardown_status).equals("with something has been run the teardown")
     end
   end
 
-  class AroundMethodTests < UnitTests
+  class AroundMethodTests < ParentContextClassTests
     desc "with multiple `around` calls"
-    setup do
-      @parent_class = Factory.modes_off_context_class do
-        around do |block|
-          self.out_status ||= ""
-          self.out_status += "p-around start, "
-          block.call
-          self.out_status += "p-around end."
-        end
-      end
 
-      @context_class = Factory.modes_off_context_class(@parent_class) do
-        around do |block|
-          self.out_status += "c-around1 start, "
-          block.call
-          self.out_status += "c-around1 end, "
-        end
-        around do |block|
-          self.out_status += "c-around2 start, "
-          block.call
-          self.out_status += "c-around2 end, "
-        end
+    let(:test_status_class) { Class.new { attr_accessor :out_status } }
+
+    should "run its parent and its own blocks in the correct order" do
+      parent_class1.around do |block|
+        self.out_status ||= ""
+        self.out_status += "p-around start, "
+        block.call
+        self.out_status += "p-around end."
       end
 
-      @test_status_class = Class.new do
-        attr_accessor :out_status
+      subject.around do |block|
+        self.out_status += "c-around1 start, "
+        block.call
+        self.out_status += "c-around1 end, "
+      end
+      subject.around do |block|
+        self.out_status += "c-around2 start, "
+        block.call
+        self.out_status += "c-around2 end, "
       end
-    end
 
-    should "run it's parent and it's own blocks in the correct order" do
-      obj = @test_status_class.new
+      obj = test_status_class.new
       subject.send("run_arounds", obj) do
         obj.instance_eval{ self.out_status += "TEST, " }
       end
 
-      exp = "p-around start, c-around1 start, c-around2 start, "\
-            "TEST, "\
-            "c-around2 end, c-around1 end, p-around end."
-      assert_equal exp, obj.out_status
+      exp =
+        "p-around start, c-around1 start, c-around2 start, "\
+        "TEST, "\
+        "c-around2 end, c-around1 end, p-around end."
+      assert_that(obj.out_status).equals(exp)
     end
   end
 end

data/test/unit/context/subject_dsl_tests.rb

@@ -2,71 +2,44 @@ require "assert"
 require "assert/context/subject_dsl"
 
 module Assert::Context::SubjectDSL
-
   class UnitTests < Assert::Context
     desc "Assert::Context::SubjectDSL"
-    subject{ @context_class }
-  end
-
-  class DescriptionsTests < UnitTests
-    desc "`descriptions` method"
-    setup do
-      descs = @descs = ["something amazing", "it really is"]
-      @context_class = Factory.modes_off_context_class do
-        descs.each{ |text| desc text }
-      end
-    end
+    subject { context_class1 }
 
-    should "return a collection containing any descriptions defined on the class" do
-      assert_equal @descs, subject.send(:descriptions)
-    end
+    let(:parent_class1)  { Factory.modes_off_context_class }
+    let(:context_class1) { Factory.modes_off_context_class(parent_class1) }
+    let(:subject_block1) { Proc.new {} }
   end
 
   class DescriptionTests < UnitTests
     desc "`description` method"
-    setup do
-      parent_text = @parent_desc = "parent description"
-      @parent_class = Factory.modes_off_context_class do
-        desc parent_text
-      end
-      text = @desc = "and the description for this context"
-      @context_class = Factory.modes_off_context_class(@parent_class) do
-        desc text
-      end
-    end
 
     should "return a string of all the inherited descriptions" do
-      exp_desc = "parent description and the description for this context"
-      assert_equal exp_desc, @context_class.description
+      parent_class1.desc("parent description")
+      subject.desc("and the description for this context")
+
+      exp = "parent description and the description for this context"
+      assert_that(subject.description).equals(exp)
     end
   end
 
   class SubjectFromLocalTests < UnitTests
     desc "`subject` method using local context"
-    setup do
-      subject_block = @subject_block = ::Proc.new{ @something }
-      @context_class = Factory.modes_off_context_class do
-        subject(&subject_block)
-      end
-    end
 
     should "set the subject block on the context class" do
-      assert_equal @subject_block, @context_class.subject
+      subject.subject(&subject_block1)
+
+      assert_that(subject.subject).equals(subject_block1)
     end
   end
 
   class SubjectFromParentTests < UnitTests
     desc "`subject` method using parent context"
-    setup do
-      parent_block = @parent_block = ::Proc.new{ @something }
-      @parent_class = Factory.modes_off_context_class do
-        subject(&parent_block)
-      end
-      @context_class = Factory.modes_off_context_class(@parent_class)
-    end
 
-    should "default to it's parents subject block" do
-      assert_equal @parent_block, @context_class.subject
+    should "default to its parents subject block" do
+      parent_class1.subject(&subject_block1)
+
+      assert_that(subject.subject).equals(subject_block1)
     end
   end
 end

data/test/unit/context/suite_dsl_tests.rb

@@ -6,38 +6,38 @@ require "assert/suite"
 module Assert::Context::SuiteDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::SuiteDSL"
-    setup do
-      @custom_suite = Factory.modes_off_suite
-      @context_class = Factory.context_class
-    end
-    subject{ @context_class }
+    subject { context_class1 }
+
+    let(:parent_class1)  { Factory.context_class }
+    let(:context_class1) { Factory.context_class(parent_class1) }
+    let(:custom_suite1)  { Factory.modes_off_suite }
 
     should "use `Assert.suite` by default" do
-      assert_equal Assert.suite, subject.suite
+      assert_that(subject.suite).equals(Assert.suite)
     end
 
     should "use any given custom suite" do
-      subject.suite(@custom_suite)
-      assert_equal @custom_suite, subject.suite
+      subject.suite(custom_suite1)
+      assert_that(subject.suite).equals(custom_suite1)
     end
   end
 
   class SuiteFromParentTests < UnitTests
     desc "`suite` method using parent context"
+
     setup do
-      @parent_class = Factory.context_class
-      @parent_class.suite(@custom_suite)
-      @context_class = Factory.context_class(@parent_class)
+      parent_class1.suite(custom_suite1)
     end
 
-    should "default to it's parent's suite" do
-      assert_equal @custom_suite, subject.suite
+    let(:custom_suite2) { Factory.modes_off_suite }
+
+    should "default to its parent's suite" do
+      assert_that(subject.suite).equals(custom_suite1)
     end
 
     should "use any given custom suite" do
-      another_suite = Factory.modes_off_suite
-      subject.suite(another_suite)
-      assert_equal another_suite, subject.suite
+      subject.suite(custom_suite2)
+      assert_that(subject.suite).equals(custom_suite2)
     end
   end
 end

data/test/unit/context/test_dsl_tests.rb

@@ -4,148 +4,144 @@ require "assert/context/test_dsl"
 module Assert::Context::TestDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::TestDSL"
-    setup do
-      @test_desc = "be true"
-      @test_block = ::Proc.new{ assert(true) }
-    end
+
+    let(:test_desc1)  { "be true" }
+    let(:test_block1) { Proc.new{ assert(true) } }
 
     should "build a test using `test` with a desc and code block" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       context, test = build_eval_context{ test(d, &b) }
 
-      assert_equal 1, context.class.suite.tests_to_run_count
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
 
-      assert_kind_of Assert::Test, test
-      assert_equal @test_desc,  test.name
-      assert_equal @test_block, test.code
+      assert_that(test).is_kind_of(Assert::Test)
+      assert_that(test.name).equals(test_desc1)
+      assert_that(test.code).equals(test_block1)
     end
 
     should "build a test using `should` with a desc and code block" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       context, test = build_eval_context{ should(d, &b) }
 
-      assert_equal 1, context.class.suite.tests_to_run_count
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
 
-      assert_kind_of Assert::Test, test
-      assert_equal "should #{@test_desc}", test.name
-      assert_equal @test_block, test.code
+      assert_that(test).is_kind_of(Assert::Test)
+      assert_that(test.name).equals("should #{test_desc1}")
+      assert_that(test.code).equals(test_block1)
     end
 
     should "build a test that skips with no msg when `test_eventually` called" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       context, test = build_eval_context{ test_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "build a test that skips with no msg  when `should_eventually` called" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       context, test = build_eval_context{ should_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "skip with the msg \"TODO\" when `test` called with no block" do
-      d = @test_desc
+      d = test_desc1
       context, test = build_eval_context { test(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "skip with the msg \"TODO\" when `should` called with no block" do
-      d = @test_desc
+      d = test_desc1
       context, test = build_eval_context { should(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "skip with the msg \"TODO\" when `test_eventually` called with no block" do
-      d = @test_desc
+      d = test_desc1
       context, test = build_eval_context{ test_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "skip with the msg \"TODO\" when `should_eventually` called with no block" do
-      d = @test_desc
+      d = test_desc1
       context, test = build_eval_context{ should_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "build a test from a macro using `test`" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       m = Assert::Macro.new{ test(d, &b); test(d, &b) }
       context_class = Factory.modes_off_context_class{ test(m) }
 
-      assert_equal 2, context_class.suite.tests_to_run_count
+      assert_that(context_class.suite.tests_to_run_count).equals(2)
     end
 
     should "build a test from a macro using `should`" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       m = Assert::Macro.new{ should(d, &b); should(d, &b) }
       context_class = Factory.modes_off_context_class{ should(m) }
 
-      assert_equal 2, context_class.suite.tests_to_run_count
+      assert_that(context_class.suite.tests_to_run_count).equals(2)
     end
 
     should "build a test that skips from a macro using `test_eventually`" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       m = Assert::Macro.new{ test(d, &b); test(d, &b) }
       context, test = build_eval_context{ test_eventually(m) }
 
-      assert_equal 1, context.class.suite.tests_to_run_count
-      assert_raises(Assert::Result::TestSkipped) do
-        context.instance_eval(&test.code)
-      end
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(-> { context.instance_eval(&test.code) }).
+        raises(Assert::Result::TestSkipped)
     end
 
     should "build a test that skips from a macro using `should_eventually`" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       m = Assert::Macro.new{ should(d, &b); should(d, &b) }
       context, test = build_eval_context{ should_eventually(m) }
 
-      assert_equal 1, context.class.suite.tests_to_run_count
-      assert_raises(Assert::Result::TestSkipped) do
-        context.instance_eval(&test.code)
-      end
-
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(-> { context.instance_eval(&test.code) }).
+        raises(Assert::Result::TestSkipped)
     end
 
     private
 
     def build_eval_context(&build_block)
-      context_class = Factory.modes_off_context_class &build_block
+      context_class = Factory.modes_off_context_class(&build_block)
       test = context_class.suite.sorted_tests_to_run.to_a.last
       [context_class.new(test, test.config, proc{ |r| }), test]
     end