assert 0.1.0

data/test/test/running_test.rb

@@ -0,0 +1,327 @@
+require 'assert'
+
+class Assert::Test::RunningTest < Assert::Context
+  desc "Assert tests that are run"
+
+  class NothingTest < Assert::Test::RunningTest
+    desc "and does nothing"
+    setup do
+      @test = Factory.test
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 0 results" do
+      assert_equal 0, subject.result_count
+    end
+
+  end
+
+
+
+  class PassTest < Assert::Test::RunningTest
+    desc "and passes a single assertion"
+    setup do
+      @test = Factory.test{ assert(1 == 1) }
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 1 result" do
+      assert_equal 1, subject.result_count
+    end
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+  end
+
+
+
+  class FailTest < Assert::Test::RunningTest
+    desc "and fails a single assertion"
+    setup do
+      @test = Factory.test{ assert(1 == 0) }
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 1 result" do
+      assert_equal 1, subject.result_count
+    end
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+  end
+
+
+
+  class SkipTest < Assert::Test::RunningTest
+    desc "and skips"
+    setup do
+      @test = Factory.test{ skip }
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 1 result" do
+      assert_equal 1, subject.result_count
+    end
+    should "have 1 skip result" do
+      assert_equal 1, subject.result_count(:skip)
+    end
+
+  end
+
+
+
+  class ErrorTest < Assert::Test::RunningTest
+    desc "and errors"
+    setup do
+      @test = Factory.test{ raise("WHAT") }
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 1 result" do
+      assert_equal 1, subject.result_count
+    end
+    should "have 1 error result" do
+      assert_equal 1, subject.result_count(:error)
+    end
+
+  end
+
+
+
+  class MixedTest < Assert::Test::RunningTest
+    desc "and has 1 pass and 1 fail assertion"
+    setup do
+      @test = Factory.test do
+        assert(1 == 1)
+        assert(1 == 0)
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+  end
+
+
+
+  class MixedSkipTest < Assert::Test::RunningTest
+    desc "and has 1 pass and 1 fail assertion with a skip call in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 1)
+        skip
+        assert(1 == 0)
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+    should "have a skip for its last result" do
+      assert_kind_of Assert::Result::Skip, subject.results.last
+    end
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+    should "have 1 skip result" do
+      assert_equal 1, subject.result_count(:skip)
+    end
+    should "have 0 fail results" do
+      assert_equal 0, subject.result_count(:fail)
+    end
+
+  end
+
+
+
+  class MixedErrorTest < Assert::Test::RunningTest
+    desc "and has 1 pass and 1 fail assertion with an exception raised in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 1)
+        raise Exception, "something errored"
+        assert(1 == 0)
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "have an error for its last result" do
+      assert_kind_of Assert::Result::Error, subject.results.last
+    end
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+    should "have 1 error result" do
+      assert_equal 1, subject.result_count(:error)
+    end
+    should "have 0 fail results" do
+      assert_equal 0, subject.result_count(:fail)
+    end
+
+  end
+
+
+
+  class MixedPassTest < Assert::Test::RunningTest
+    desc "and has 1 pass and 1 fail assertion with a pass call in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 1)
+        pass
+        assert(1 == 0)
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "have a pass for its last result" do
+      assert_kind_of Assert::Result::Fail, subject.results.last
+    end
+    should "have 3 total results" do
+      assert_equal 3, subject.result_count
+    end
+    should "have 2 pass results" do
+      assert_equal 2, subject.result_count(:pass)
+    end
+    should "have 1 fail results" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+  end
+
+
+
+  class MixedFailTest < Assert::Test::RunningTest
+    desc "and has 1 pass and 1 fail assertion with a fail call in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 0)
+        fail
+        assert(1 == 1)
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "have a fail for its last result" do
+      assert_kind_of Assert::Result::Pass, subject.results.last
+    end
+    should "have 3 total results" do
+      assert_equal 3, subject.result_count
+    end
+    should "have 1 pass results" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+    should "have 2 fail results" do
+      assert_equal 2, subject.result_count(:fail)
+    end
+
+  end
+
+
+
+  class MixedFlunkTest < Assert::Test::RunningTest
+    desc "and has 1 pass and 1 fail assertion with a flunk call in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 0)
+        flunk
+        assert(1 == 1)
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "have a fail for its last result" do
+      assert_kind_of Assert::Result::Pass, subject.results.last
+    end
+    should "have 3 total results" do
+      assert_equal 3, subject.result_count
+    end
+    should "have 1 pass results" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+    should "have 2 fail results" do
+      assert_equal 2, subject.result_count(:fail)
+    end
+
+  end
+
+
+
+  class WithSetupTest < Assert::Test::RunningTest
+    desc "a Test that runs and has assertions that depend on a setup block"
+    setup do
+      @context_class = Factory.context_class do
+        setup{ @needed = true }
+      end
+      @test = Factory.test("something", @context_class) do
+        assert(@needed)
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 1 total result" do
+      assert_equal 1, subject.result_count
+    end
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+  end
+
+
+
+  class WithTeardownTest < Assert::Test::RunningTest
+    desc "a Test that runs and has assertions with a teardown block"
+    setup do
+      new_message = @new_message = "HOLLA"
+      @context_class = Factory.context_class do
+        teardown do
+          pass_result = @__running_test__.pass_results.first
+          pass_result.instance_variable_set("@message", new_message)
+        end
+      end
+      @test = Factory.test("something amazing", @context_class) do
+        assert(true)
+      end
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 1 total result" do
+      assert_equal 1, subject.result_count
+    end
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+    should "have modifed the message" do
+      assert_equal @new_message, subject.pass_results.first.message
+    end
+
+  end
+
+end

data/test/test_test.rb

@@ -0,0 +1,184 @@
+require 'assert'
+
+class Assert::Test::BasicTest < Assert::Context
+  desc "Assert test"
+  setup do
+    test_name = "test: should do something amazing"
+    @test_code = lambda{ assert(true) }
+    context_desc = "context class"
+    @context_class = Factory.context_class do
+      desc context_desc
+    end
+    @test = Factory.test(test_name, @context_class, @test_code)
+    @expected_name = [ context_desc, test_name.gsub(/^test:\s+should/, "should") ].join(" ")
+  end
+  subject{ @test }
+
+  INSTANCE_METHODS = [
+    :name, :code, :context_class,
+    :results, :results=,
+    :run, :run_setup, :run_teardown,
+    :result_count,
+    Assert::Result.types.keys.collect{|k| "#{k}_results".to_sym }
+  ].flatten
+  INSTANCE_METHODS.each do |method|
+    should "respond to the instance method ##{method}" do
+      assert_respond_to subject, method
+    end
+  end
+
+  should "set it's test name to the context description with the passed in name cleaned" do
+    assert_equal @expected_name, subject.name
+  end
+  should "set it's context class and code from its initialize" do
+    assert_equal @context_class, subject.context_class
+    assert_equal @test_code, subject.code
+  end
+  should "have zero results before running" do
+    assert_equal 0, subject.result_count
+  end
+  should "have a custom inspect that only shows limited attributes" do
+    attributes_string = [ :name, :context_class, :results ].collect do |method|
+      "@#{method}=#{subject.send(method).inspect}"
+    end.join(" ")
+    expected = "#<#{subject.class} #{attributes_string}>"
+    assert_equal expected, subject.inspect
+  end
+
+  teardown do
+    TEST_ASSERT_SUITE.clear
+  end
+
+
+
+  # testing <type>_results methods and result_count(<type>)
+  class ResultsTest < Assert::Test::BasicTest
+    desc "methods from Assert::Result.types"
+
+    class PassFailIgnoreTest < ResultsTest
+      setup do
+        @test = Factory.test("pass fail ignore test", @context_class) do
+          ignore("something")
+          assert(true)
+          assert(false)
+          ignore("something else")
+          assert(34)
+          assert(nil)
+        end
+        @test.run
+      end
+      subject{ @test }
+
+      should "return the pass results with #pass_results" do
+        assert_kind_of Array, subject.pass_results
+        assert_equal 2, subject.pass_results.size
+        subject.pass_results.each do |result|
+          assert_kind_of Assert::Result::Pass, result
+        end
+      end
+      should "return the size of #pass_results with #result_count(:pass)" do
+        assert_equal(subject.pass_results.size, subject.result_count(:pass))
+      end
+      should "return the fail results with #fail_results" do
+        assert_kind_of Array, subject.fail_results
+        assert_equal 2, subject.fail_results.size
+        subject.fail_results.each do |result|
+          assert_kind_of Assert::Result::Fail, result
+        end
+      end
+      should "return the size of #fail_results with #result_count(:fail)" do
+        assert_equal(subject.fail_results.size, subject.result_count(:fail))
+      end
+      should "return the ignore results with #ignore_results" do
+        assert_kind_of Array, subject.ignore_results
+        assert_equal 2, subject.ignore_results.size
+        subject.ignore_results.each do |result|
+          assert_kind_of Assert::Result::Ignore, result
+        end
+      end
+      should "return the size of #ignore_results with #result_count(:ignore)" do
+        assert_equal(subject.ignore_results.size, subject.result_count(:ignore))
+      end
+      should "return the total number of tests with #result_count" do
+        assert_equal(6, subject.result_count)
+      end
+
+    end
+
+
+
+    class SkipTest < ResultsTest
+      setup do
+        @test = Factory.test("skip test", @context_class) do
+          skip
+        end
+        @test.run
+      end
+      subject{ @test }
+
+      should "return the skip results with #skip_results" do
+        assert_kind_of Array, subject.skip_results
+        assert_equal 1, subject.skip_results.size
+        subject.skip_results.each do |result|
+          assert_kind_of Assert::Result::Skip, result
+        end
+      end
+      should "return the size of #skip_results with #result_count(:skip)" do
+        assert_equal(subject.skip_results.size, subject.result_count(:skip))
+      end
+
+    end
+
+
+
+    class ErrorTest < ResultsTest
+      setup do
+        @test = Factory.test("error test", @context_class) do
+          raise StandardError, "WHAT"
+        end
+        @test.run
+      end
+      subject{ @test }
+
+      should "return the error results with #error_results" do
+        assert_kind_of Array, subject.error_results
+        assert_equal 1, subject.error_results.size
+        subject.error_results.each do |result|
+          assert_kind_of Assert::Result::Error, result
+        end
+      end
+      should "return the size of #error_results with #result_count(:error)" do
+        assert_equal(subject.error_results.size, subject.result_count(:error))
+      end
+
+    end
+
+  end
+
+
+
+  class ComparingTest < Assert::Test::BasicTest
+    desc "<=> another test"
+    setup do
+      @test = Factory.test("mmm")
+    end
+    subject{ @test }
+
+    should "return 1 with a test named 'aaa' (greater than it)" do
+      result = @test <=> Factory.test("aaa")
+      assert_equal(1, result)
+    end
+    should "return 0 with named the same" do
+      result = @test <=> Factory.test(@test.name)
+      assert_equal(0, result)
+    end
+    should "return -1 with a test named 'zzz' (less than it)" do
+      result = @test <=> Factory.test("zzz")
+      assert_equal(-1, result)
+    end
+
+  end
+
+
+
+end