assert 2.0.0.rc.1 → 2.0.0

data/test/unit/assertions/assert_same_tests.rb

@@ -0,0 +1,65 @@
+require 'assert'
+require 'assert/assertions'
+
+module Assert::Assertions
+
+  class AssertSameTest < Assert::Context
+    desc "the assert_same helper"
+    setup do
+      klass = Class.new; object = klass.new
+      desc = @desc = "assert same fail desc"
+      args = @args = [ object, klass.new, desc ]
+      @test = Factory.test do
+        assert_same(object, object) # pass
+        assert_same(*args)          # fail
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "produce results as expected" do
+      assert_equal 2, subject.result_count
+      assert_equal 1, subject.result_count(:pass)
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+    should "have a fail message with custom and generic explanations" do
+      exp = "#{@args[2]}\n"\
+            "Expected #{@args[1].inspect} (#{@args[1].object_id})"\
+            " to be the same as #{@args[0].inspect} (#{@args[0].object_id})."
+      assert_equal exp, subject.fail_results.first.message
+    end
+
+  end
+
+  class AssertNotSameTests < Assert::Context
+    desc "the assert_not_same helper"
+    setup do
+      klass = Class.new; object = klass.new
+      desc = @desc = "assert not same fail desc"
+      args = @args = [ object, object, desc ]
+      @test = Factory.test do
+        assert_not_same(*args)             # fail
+        assert_not_same(object, klass.new) # pass
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "produce results as expected" do
+      assert_equal 2, subject.result_count
+      assert_equal 1, subject.result_count(:pass)
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+    should "have a fail message with custom and generic explanations" do
+      exp = "#{@args[2]}\n"\
+            "#{@args[1].inspect} (#{@args[1].object_id}) not expected"\
+            " to be the same as #{@args[0].inspect} (#{@args[0].object_id})."
+      assert_equal exp, subject.fail_results.first.message
+    end
+
+  end
+
+end
+

data/test/unit/assertions_tests.rb

@@ -0,0 +1,65 @@
+require 'assert'
+require 'assert/assertions'
+
+module Assert::Assertions
+
+  class BasicTests < Assert::Context
+
+    desc "An assert context"
+    setup do
+      @context_class = Factory.context_class
+      @context = @context_class.new
+    end
+    subject{ @context }
+
+    should have_imeths :assert_block, :assert_not_block, :refute_block
+    should have_imeths :assert_raises, :assert_not_raises
+    should have_imeths :assert_raise, :assert_not_raise, :assert_nothing_raised
+    should have_imeths :assert_kind_of, :assert_not_kind_of, :refute_kind_of
+    should have_imeths :assert_instance_of, :assert_not_instance_of, :refute_instance_of
+    should have_imeths :assert_respond_to, :assert_responds_to
+    should have_imeths :assert_not_respond_to, :assert_not_responds_to
+    should have_imeths :refute_respond_to, :refute_responds_to
+    should have_imeths :assert_same, :assert_not_same, :refute_same
+    should have_imeths :assert_equal, :assert_not_equal, :refute_equal
+    should have_imeths :assert_match, :assert_not_match, :assert_no_match, :refute_match
+    should have_imeths :assert_empty, :assert_not_empty, :refute_empty
+    should have_imeths :assert_includes, :assert_not_includes
+    should have_imeths :assert_included, :assert_not_included
+    should have_imeths :refute_includes, :refute_included
+    should have_imeths :assert_nil, :assert_not_nil, :refute_nil
+    should have_imeths :assert_file_exists, :assert_not_file_exists, :refute_file_exists
+
+  end
+
+  class IgnoredTests < BasicTests
+    desc "ignored assertions helpers"
+    setup do
+      @tests = Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
+        context_info = Factory.context_info(@context_class)
+        Factory.test("ignored assertion helper #{helper}", context_info) do
+          self.send(helper, "doesn't matter")
+        end
+      end
+      @expected_messages = Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
+        "The assertion `#{helper}` is not supported."\
+        " Please use another assertion or the basic `assert`."
+      end
+      @results = @tests.map(&:run).flatten
+    end
+    subject{ @results }
+
+    should "have an ignored result for each helper in the constant" do
+      subject.each do |result|
+        assert_kind_of Assert::Result::Ignore, result
+      end
+      assert_equal(Assert::Assertions::IGNORED_ASSERTION_HELPERS.size, subject.size)
+    end
+
+    should "have a custom ignore message for each helper in the constant" do
+      assert_equal(@expected_messages, subject.collect(&:message))
+    end
+
+  end
+
+end

data/test/unit/context/basic_singleton_tests.rb

@@ -0,0 +1,86 @@
+require 'assert'
+require 'assert/context'
+
+class Assert::Context
+
+  # `ContextSingletonTests` defined in `test/helper.rb`
+  class BasicSingletonTests < ContextSingletonTests
+    should have_instance_methods :setup_once, :before_once, :startup
+    should have_instance_methods :teardown_once, :after_once, :shutdown
+    should have_instance_methods :setup, :before, :setups
+    should have_instance_methods :teardown, :after, :teardowns
+    should have_instance_methods :description, :desc, :describe, :subject
+    should have_instance_methods :test, :test_eventually, :test_skip
+    should have_instance_methods :should, :should_eventually, :should_skip
+
+  end
+
+  class DescriptionsTests < BasicSingletonTests
+    desc "`descriptions` method"
+    setup do
+      descs = @descs = [ "something amazing", "it really is" ]
+      @context_class = Factory.context_class do
+        descs.each{ |text| desc text }
+      end
+    end
+
+    should "return a collection containing any descriptions defined on the class" do
+      context_descs = subject.send :descriptions
+      assert_equal @descs, context_descs
+    end
+
+  end
+
+  class DescriptionTests < BasicSingletonTests
+    desc "`description` method"
+    setup do
+      parent_text = @parent_desc = "parent description"
+      @parent_class = Factory.context_class do
+        desc parent_text
+      end
+      text = @desc = "and the description for this context"
+      @context_class = Factory.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
+    end
+
+  end
+
+  class SubjectFromLocalTests < BasicSingletonTests
+    desc "subject method using local context"
+    setup do
+      subject_block = @subject_block = ::Proc.new{ @something }
+      @context_class = Factory.context_class do
+        subject(&subject_block)
+      end
+    end
+    subject{ @subject_block }
+
+    should "set the subject block on the context class" do
+      assert_equal @context_class.subject, subject
+    end
+
+  end
+
+  class SubjectFromParentTests < BasicSingletonTests
+    desc "subject method using parent context"
+    setup do
+      parent_block = @parent_block = ::Proc.new{ @something }
+      @parent_class = Factory.context_class do
+        subject(&parent_block)
+      end
+      @context_class = Factory.context_class(@parent_class)
+    end
+    subject{ @parent_block }
+
+    should "default to it's parents subject block" do
+      assert_equal @context_class.subject, subject
+    end
+  end
+
+end

data/test/unit/context/setup_teardown_singleton_tests.rb

@@ -0,0 +1,105 @@
+require 'assert'
+require 'assert/context'
+
+class Assert::Context
+
+  # `ContextSingletonTests` defined in `test/helper.rb`
+  class SetupTeardownSingletonTests < ContextSingletonTests
+    desc "setup and teardown"
+  end
+
+  class SetupTeardownOnceMethodsTests < SetupTeardownSingletonTests
+    desc "once methods"
+    setup do
+      block = @block = ::Proc.new{ something_once = true }
+      @context_class = Factory.context_class do
+        setup_once(&block)
+        teardown_once(&block)
+      end
+    end
+    teardown do
+      Assert.suite.send(:setups).reject!{ |b| b == @block }
+    end
+
+    should "add the block to the suite" do
+      assert_includes @block, Assert.suite.send(:setups)
+      assert_includes @block, Assert.suite.send(:teardowns)
+    end
+
+  end
+
+  class SetupTeardownMethodsTests < SetupTeardownSingletonTests
+    desc "methods"
+    setup do
+      block = @block = ::Proc.new{ something = true }
+      @context_class = Factory.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)
+    end
+
+  end
+
+  class SetupTeardownWithMethodNameTests < SetupTeardownSingletonTests
+    desc "methods given a method name"
+    setup do
+      method_name = @method_name = :something_amazing
+      @context_class = Factory.context_class do
+        setup(method_name)
+        teardown(method_name)
+      end
+    end
+
+    should "add the method name to the context" do
+      assert_includes @method_name, subject.send(:setups)
+      assert_includes @method_name, subject.send(:teardowns)
+    end
+
+  end
+
+  class SetupTeardownMultipleTests < SetupTeardownSingletonTests
+    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.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.context_class(@parent_class) do
+        setup(&context_setup_block)
+        setup(:setup_something)
+        teardown(:teardown_something)
+        teardown(&context_teardown_block)
+      end
+
+      @test_status_class = Class.new do
+        attr_accessor :setup_status, :teardown_status
+        define_method(:setup_something) do
+          self.setup_status += " with something"
+        end
+        define_method(:teardown_something) do
+          self.teardown_status = "with something "
+        end
+      end
+    end
+
+    should "run it's parent and it's own blocks in the correct order" do
+      subject.setup(obj = @test_status_class.new)
+      assert_equal "the setup has been run with something", obj.setup_status
+
+      subject.teardown(obj = @test_status_class.new)
+      assert_equal "with something has been run the teardown", obj.teardown_status
+    end
+
+  end
+
+end

data/test/unit/context/test_should_singleton_tests.rb

@@ -0,0 +1,134 @@
+require 'assert'
+require 'assert/context'
+
+class Assert::Context
+
+  # `ContextSingletonTests` defined in `test/helper.rb`
+  class TestShouldSingletonTests < ContextSingletonTests
+    desc "test and should methods"
+    setup do
+      @test_count_before = Assert.suite.tests.size
+      @test_desc = "be true"
+      @test_block = ::Proc.new{ assert(true) }
+    end
+
+    should "build a test using `test` with a desc and code block" do
+      d, b = @test_desc, @test_block
+      Factory.context_class { test(d, &b) }
+
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+
+      exp_test_name = @test_desc
+      built_test = Assert.suite.tests.last
+      assert_kind_of Assert::Test, built_test
+      assert_equal exp_test_name, built_test.name
+      assert_equal @test_block, built_test.code
+    end
+
+    should "build a test using `should` with a desc and code block" do
+      d, b = @test_desc, @test_block
+      Factory.context_class { should(d, &b) }
+
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+
+      exp_test_name = "should #{@test_desc}"
+      built_test = Assert.suite.tests.last
+      assert_kind_of Assert::Test, built_test
+      assert_equal exp_test_name, built_test.name
+      assert_equal @test_block, built_test.code
+    end
+
+    should "build a test that skips when `test` called with no block" do
+      d = @test_desc
+      context_class = Factory.context_class { test(d) }
+      context_info  = Factory.context_info(context_class)
+      context = context_class.new(Factory.test("whatever", context_info))
+
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_raises(Assert::Result::TestSkipped) do
+        context.instance_eval(&Assert.suite.tests.last.code)
+      end
+    end
+
+    should "build a test that skips when `should` called with no block" do
+      d = @test_desc
+      context_class = Factory.context_class { should(d) }
+      context_info  = Factory.context_info(context_class)
+      context = context_class.new(Factory.test("whatever", context_info))
+
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_raises(Assert::Result::TestSkipped) do
+        context.instance_eval(&Assert.suite.tests.last.code)
+      end
+    end
+
+    should "build a test that skips when `test_eventually` called" do
+      d, b = @test_desc, @test_block
+      context_class = Factory.context_class { test_eventually(d, &b) }
+      context_info  = Factory.context_info(context_class)
+      context = context_class.new(Factory.test("whatever", context_info))
+
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_raises(Assert::Result::TestSkipped) do
+        context.instance_eval(&Assert.suite.tests.last.code)
+      end
+    end
+
+    should "build a test that skips when `should_eventually` called" do
+      d, b = @test_desc, @test_block
+      context_class = Factory.context_class { should_eventually(d, &b) }
+      context_info  = Factory.context_info(context_class)
+      context = context_class.new(Factory.test("whatever", context_info))
+
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_raises(Assert::Result::TestSkipped) do
+        context.instance_eval(&Assert.suite.tests.last.code)
+      end
+    end
+
+    should "build a test from a macro using `test`" do
+      d, b = @test_desc, @test_block
+      m = Assert::Macro.new{ test(d, &b); test(d, &b) }
+      Factory.context_class { test(m) }
+
+      assert_equal @test_count_before+2, Assert.suite.tests.size
+    end
+
+    should "build a test from a macro using `should`" do
+      d, b = @test_desc, @test_block
+      m = Assert::Macro.new{ should(d, &b); should(d, &b) }
+      Factory.context_class { should(m) }
+
+      assert_equal @test_count_before+2, Assert.suite.tests.size
+    end
+
+    should "build a test that skips from a macro using `test_eventually`" do
+      d, b = @test_desc, @test_block
+      m = Assert::Macro.new{ test(d, &b); test(d, &b) }
+      context_class = Factory.context_class { test_eventually(m) }
+      context_info  = Factory.context_info(context_class)
+      context = context_class.new(Factory.test("whatever", context_info))
+
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_raises(Assert::Result::TestSkipped) do
+        context.instance_eval(&Assert.suite.tests.last.code)
+      end
+    end
+
+    should "build a test that skips from a macro using `should_eventually`" do
+      d, b = @test_desc, @test_block
+      m = Assert::Macro.new{ should(d, &b); should(d, &b) }
+      context_class = Factory.context_class { should_eventually(m) }
+      context_info  = Factory.context_info(context_class)
+      context = context_class.new(Factory.test("whatever", context_info))
+
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_raises(Assert::Result::TestSkipped) do
+        context.instance_eval(&Assert.suite.tests.last.code)
+      end
+
+    end
+
+  end
+
+end