assert 0.1.0

data/test/result_set_test.rb

@@ -0,0 +1,89 @@
+require 'assert'
+
+require 'assert/result_set'
+require 'assert/result'
+require 'assert/view/base'
+
+class FakeView < Assert::View::Base
+  attr_accessor :printed
+
+  def initialize(suite, output_io)
+    super
+    self.printed = []
+  end
+
+  def print_runtime_result(result)
+    self.printed.push(result)
+  end
+
+end
+
+class Assert::ResultSet
+  class BasicTest < Assert::Context
+    desc "Assert result set"
+    setup do
+      @result_set = Assert::ResultSet.new
+    end
+    subject { @result_set }
+
+    INSTANCE_METHODS = [
+      :view, :view=
+    ]
+    INSTANCE_METHODS.each do |method|
+      should "respond to the instance method ##{method}" do
+        assert_respond_to subject, method
+      end
+    end
+
+
+
+    class ViewTest < BasicTest
+      desc "view"
+      setup do
+        @view_s = ""
+        @view = @result_set.view = FakeView.new(nil, StringIO.new(@view_s, "w+"))
+
+        @pass_result = Assert::Result::Pass.new("test", "pass", [])
+        @result_set << @pass_result
+        @fail_result = Assert::Result::Fail.new("test", "fail", [])
+        @result_set << @fail_result
+        @skip_result = Assert::Result::Skip.new("test", RuntimeError.new)
+        @result_set << @skip_result
+        @error_result = Assert::Result::Error.new("test", RuntimeError.new)
+        @result_set << @error_result
+      end
+      subject{ @view }
+
+      should "have 'printed' 1 pass result" do
+        pass_results = @view.printed.reject{|r| !r.pass? }
+        assert_equal 1, pass_results.size
+        assert_kind_of Assert::Result::Pass, pass_results.first
+        assert_equal @pass_result.test_name, pass_results.first.test_name
+        assert_equal @pass_result.message, pass_results.first.message
+      end
+      should "have 'printed' 1 fail result" do
+        fail_results = @view.printed.reject{|r| !r.fail? }
+        assert_equal 1, fail_results.size
+        assert_kind_of Assert::Result::Fail, fail_results.first
+        assert_equal @fail_result.test_name, fail_results.first.test_name
+        assert_equal @fail_result.message, fail_results.first.message
+      end
+      should "have 'printed' 1 skip result" do
+        skip_results = @view.printed.reject{|r| !r.skip? }
+        assert_equal 1, skip_results.size
+        assert_kind_of Assert::Result::Skip, skip_results.first
+        assert_equal @skip_result.test_name, skip_results.first.test_name
+        assert_equal @skip_result.message, skip_results.first.message
+      end
+      should "have 'printed' 1 error result" do
+        error_results = @view.printed.reject{|r| !r.error? }
+        assert_equal 1, error_results.size
+        assert_kind_of Assert::Result::Error, error_results.first
+        assert_equal @error_result.test_name, error_results.first.test_name
+        assert_equal @error_result.message, error_results.first.message
+      end
+
+    end
+
+  end
+end

data/test/result_test.rb

@@ -0,0 +1,255 @@
+require 'assert'
+
+require 'assert/result'
+
+module Assert::Result
+
+  class BacktraceTest < Assert::Context
+    desc "a result backtrace"
+    setup{ @backtrace = Backtrace.new(caller) }
+    subject { @backtrace }
+
+    INSTANCE_METHODS = [
+      :to_s, :filtered
+    ]
+    INSTANCE_METHODS.each do |method|
+      should "respond to the instance method ##{method}" do
+        assert_respond_to subject, method
+      end
+    end
+
+    should "be an Array" do
+      assert_kind_of ::Array, subject
+    end
+
+    should "render as a string by joining on the newline" do
+      assert_equal subject.join("\n"), subject.to_s
+    end
+
+    should "another backtrace when filtered" do
+      assert_kind_of Backtrace, subject
+    end
+
+    should "default itself when created from nil" do
+      assert_equal ["No backtrace"], Backtrace.new
+    end
+  end
+
+  class BaseTest < Assert::Context
+    desc "a base result"
+    setup do
+      @result = Assert::Result::Base.new("a test name", "a message", ["line 1", "line2"])
+    end
+    subject{ @result }
+
+    INSTANCE_METHODS = [
+      :test_name, :message, :backtrace, :to_sym, :to_s, :trace
+    ]
+    INSTANCE_METHODS.each do |method|
+      should "respond to the instance method ##{method}" do
+        assert_respond_to subject, method
+      end
+    end
+
+    Assert::Result.types.keys.each do |type|
+      should "respond to the instance method ##{type}?" do
+        assert_respond_to subject, "#{type}?"
+      end
+
+      should "not be #{type}" do
+        assert_equal false, subject.send("#{type}?")
+      end
+    end
+
+    should "nil out empty messages" do
+      assert_equal nil, Assert::Result::Base.new("a test name", "").message
+    end
+
+    should "show only its class and message when inspected" do
+      assert_equal "#<#{subject.class} @message=#{subject.message.inspect}>", subject.inspect
+    end
+
+  end
+
+  class ToStringTest < BaseTest
+    should "include its test context name in the to_s" do
+      assert subject.to_s.include?(subject.test_name)
+    end
+
+    should "include its test name in the to_s" do
+      assert subject.to_s.include?(subject.test_name)
+    end
+
+    should "include its message in the to_s" do
+      assert subject.to_s.include?(subject.message)
+    end
+
+    should "include its trace in the to_s" do
+      assert subject.to_s.include?(subject.trace)
+    end
+
+    should "have a trace with the first filtered line of the backtrace" do
+      assert_equal subject.backtrace.filtered.first, subject.trace
+    end
+  end
+
+  class PassTest < Assert::Context
+    desc "a pass result"
+    setup do
+      @result = Assert::Result::Pass.new("test", "passed", [])
+    end
+    subject { @result }
+
+    should "be pass?" do
+      assert_equal true, subject.pass?
+    end
+
+    Assert::Result.types.keys.reject{|k| k == :pass}.each do |type|
+      should "not be #{type}?" do
+        assert_equal false, subject.send("#{type}?")
+      end
+    end
+
+    should "know its to_sym" do
+      assert_equal :passed, subject.to_sym
+    end
+
+    should "include PASS in its to_s" do
+      assert subject.to_s.include?("PASS")
+    end
+  end
+
+  class FailTest < Assert::Context
+    desc "a fail result"
+    setup do
+      @result = Assert::Result::Fail.new("test", "failed", [])
+    end
+    subject { @result }
+
+    should "be fail?" do
+      assert_equal true, subject.fail?
+    end
+
+    Assert::Result.types.keys.reject{|k| k == :fail}.each do |type|
+      should "not be #{type}?" do
+        assert_equal false, subject.send("#{type}?")
+      end
+    end
+
+    should "know its to_sym" do
+      assert_equal :failed, subject.to_sym
+    end
+
+    should "include FAIL in its to_s" do
+      assert subject.to_s.include?("FAIL")
+    end
+  end
+
+  class IgnoreTest < Assert::Context
+    desc "an ignore result"
+    setup do
+      @result = Assert::Result::Ignore.new("test", "ignored", [])
+    end
+    subject { @result }
+
+    should "be ignore?" do
+      assert_equal true, subject.ignore?
+    end
+
+    Assert::Result.types.keys.reject{|k| k == :ignore}.each do |type|
+      should "not be #{type}?" do
+        assert_equal false, subject.send("#{type}?")
+      end
+    end
+
+    should "know its to_sym" do
+      assert_equal :ignored, subject.to_sym
+    end
+
+    should "include IGNORE in its to_s" do
+      assert subject.to_s.include?("IGNORE")
+    end
+  end
+
+  class FromExceptionTest < Assert::Context
+    before do
+      begin
+        raise Exception, "test error"
+      rescue Exception => err
+        @exception = err
+      end
+      @result = Assert::Result::FromException.new("test", @exception)
+    end
+    subject{ @result }
+
+    should "have the same backtrace as the original exception it was created from" do
+      assert_equal @exception.backtrace, subject.backtrace
+    end
+
+  end
+
+  class SkippedRuntimeErrorTest < Assert::Context
+
+    should "be a runtime error" do
+      assert_kind_of RuntimeError, Assert::Result::TestSkipped.new
+    end
+
+  end
+
+  class SkipTest < FromExceptionTest
+    desc "a skip result"
+    setup do
+      @result = Assert::Result::Skip.new("test", @exception)
+    end
+    subject { @result }
+
+    should "be skip?" do
+      assert_equal true, subject.skip?
+    end
+
+    Assert::Result.types.keys.reject{|k| k == :skip}.each do |type|
+      should "not be #{type}?" do
+        assert_equal false, subject.send("#{type}?")
+      end
+    end
+
+    should "know its to_sym" do
+      assert_equal :skipped, subject.to_sym
+    end
+
+    should "include SKIP in its to_s" do
+      assert subject.to_s.include?("SKIP")
+    end
+  end
+
+  class ErrorTest < FromExceptionTest
+    desc "an error result"
+    setup do
+      @result = Assert::Result::Error.new("test", @exception)
+    end
+    subject { @result }
+
+    should "be error?" do
+      assert_equal true, subject.error?
+    end
+
+    Assert::Result.types.keys.reject{|k| k == :error}.each do |type|
+      should "not be #{type}?" do
+        assert_equal false, subject.send("#{type}?")
+      end
+    end
+
+    should "know its to_sym" do
+      assert_equal :errored, subject.to_sym
+    end
+
+    should "include ERRORED in its to_s" do
+      assert subject.to_s.include?("ERROR")
+    end
+
+    should "have a trace created from the original exception's unfiltered backtrace" do
+      assert_equal @exception.backtrace.join("\n"), subject.trace
+    end
+  end
+
+end

data/test/runner_test.rb

@@ -0,0 +1,33 @@
+require 'assert'
+
+require 'assert/suite'
+require 'assert/view/base'
+require 'assert/runner'
+
+class Assert::Runner
+
+  class BasicTest < Assert::Context
+    desc "a basic runner"
+    setup do
+      @suite  = Assert::Suite.new
+      @view   = Assert::View::Base.new(@suite, StringIO.new("", "w+"))
+      @runner = Assert::Runner.new(@suite, @view)
+    end
+    subject { @runner }
+
+    INSTANCE_METHODS = [
+      :run, :count
+    ]
+    INSTANCE_METHODS.each do |method|
+      should "respond to the instance method ##{method}" do
+        assert_respond_to subject, method
+      end
+    end
+
+    should "return an integer exit code" do
+      assert_equal 0, subject.run
+    end
+
+  end
+
+end

data/test/suite_test.rb

@@ -0,0 +1,200 @@
+require 'assert'
+
+require 'assert/suite'
+require 'assert/context'
+require 'assert/test'
+require 'test/fixtures/inherited_stuff'
+require 'test/fixtures/sample_context'
+
+
+class Assert::Suite
+
+  class BasicTest < Assert::Context
+    desc "an basic suite"
+    setup do
+      @suite = Assert::Suite.new
+    end
+    subject { @suite }
+
+    INSTANCE_METHODS = [
+      :start_time, :end_time, :start_time=, :end_time=,
+      :<<,
+      :contexts, :tests, :ordered_tests, :ordered_results,
+      :count, :test_count, :result_count,
+      :run_time
+    ]
+    INSTANCE_METHODS.each do |method|
+      should "respond to the instance method ##{method}" do
+        assert_respond_to subject, method
+      end
+    end
+
+    should "be a hash" do
+      assert_kind_of ::Hash, subject
+    end
+
+    should "push contexts on itself" do
+      context_class = Factory.context_class
+      subject << context_class
+      assert_equal true, subject.has_key?(context_class)
+      assert_equal [], subject[context_class]
+    end
+
+    should "determine a klass' local public test methods" do
+      assert_equal(
+        ["test_subclass_stuff", "test_mixin_stuff"].sort,
+        subject.send(:local_public_test_methods, SubStuff).sort
+      )
+    end
+
+    should "have zero run time by default" do
+      assert_equal 0, subject.run_time
+    end
+
+  end
+
+  class WithTestsTest < Assert::Context
+    desc "a suite with tests"
+    setup do
+      @suite = Assert::Suite.new
+      context_class = Factory.context_class
+      @suite[context_class] = [
+        Factory.test("should do nothing", context_class),
+        Factory.test("should pass", context_class) do
+          assert(1==1)
+          refute(1==0)
+        end,
+        Factory.test("should fail", context_class) do
+          ignore
+          assert(1==0)
+          refute(1==1)
+        end,
+        Factory.test("should be ignored", context_class) do
+          ignore
+        end,
+        Factory.test("should skip", context_class) do
+          skip
+          ignore
+          assert(1==1)
+        end,
+        Factory.test("should error", context_class) do
+          raise Exception
+          ignore
+          assert(1==1)
+        end
+      ]
+      @suite.tests.each(&:run)
+    end
+    subject{ @suite }
+
+    should "know how many tests it has" do
+      assert_equal 6, subject.test_count
+    end
+
+    should "know its ordered tests" do
+      assert_equal subject.test_count, subject.ordered_tests.size
+    end
+
+    should "know how many results it has" do
+      assert_equal 8, subject.result_count
+    end
+
+    should "know its ordered results" do
+      assert_equal subject.test_count, subject.ordered_tests.size
+    end
+
+    should "know how many pass results it has" do
+      assert_equal 2, subject.result_count(:pass)
+    end
+
+    should "know how many fail results it has" do
+      assert_equal 2, subject.result_count(:fail)
+    end
+
+    should "know how many ignore results it has" do
+      assert_equal 2, subject.result_count(:ignore)
+    end
+
+    should "know how many skip results it has" do
+      assert_equal 1, subject.result_count(:skip)
+    end
+
+    should "know how many error results it has" do
+      assert_equal 1, subject.result_count(:error)
+    end
+
+  end
+
+  class CountTest < WithTestsTest
+
+    should "count its tests" do
+      assert_equal subject.test_count, subject.count(:tests)
+    end
+
+    should "count its results" do
+      assert_equal subject.result_count, subject.count(:results)
+    end
+
+    should "count its passed results" do
+      assert_equal subject.result_count(:pass), subject.count(:passed)
+      assert_equal subject.result_count(:pass), subject.count(:pass)
+    end
+
+    should "count its failed results" do
+      assert_equal subject.result_count(:fail), subject.count(:failed)
+      assert_equal subject.result_count(:fail), subject.count(:fail)
+    end
+
+    should "count its ignored results" do
+      assert_equal subject.result_count(:ignore), subject.count(:ignored)
+      assert_equal subject.result_count(:ignore), subject.count(:ignore)
+    end
+
+    should "count its skipped results" do
+      assert_equal subject.result_count(:skip), subject.count(:skipped)
+      assert_equal subject.result_count(:skip), subject.count(:skip)
+    end
+
+    should "count its errored results" do
+      assert_equal subject.result_count(:error), subject.count(:errored)
+      assert_equal subject.result_count(:error), subject.count(:error)
+    end
+
+  end
+
+
+  class TestsTest < WithTestsTest
+
+    should "build test instances to run" do
+      assert_kind_of Assert::Test, subject.tests.first
+    end
+
+  end
+
+
+  class PrepTest < Assert::Context
+    desc "a suite with a context with local public test meths"
+    setup do
+      @suite = Assert::Suite.new
+      @suite << TwoTests
+    end
+    subject{ @suite }
+
+    should "create tests from any local public test methods with a prep call" do
+      subject.send(:prep)
+      assert_equal 2, subject.test_count(TwoTests)
+    end
+
+    should "not double count local public test methods with multiple prep calls" do
+      subject.send(:prep)
+      subject.send(:prep)
+      assert_equal 2, subject.test_count(TwoTests)
+    end
+
+    should "create tests from any local public test methods with a test_count call" do
+      assert_equal 2, subject.test_count(TwoTests)
+    end
+
+  end
+
+end