assert 0.6.0 → 0.7.0

data/test/rake_tasks/scope_test.rb

@@ -0,0 +1,63 @@
+require 'assert'
+
+require 'assert/rake_tasks/scope'
+
+module Assert::RakeTasks
+
+  class ScopeTests < Assert::Context
+    desc "the scope rake tasks handler"
+    setup do
+      @scope_root = 'test/fixtures'
+      @handler = Assert::RakeTasks::Scope.new(File.join(@scope_root, 'test_root'))
+    end
+    subject { @handler }
+
+    should have_class_methods :test_file_suffix
+    should have_instance_methods :namespace, :nested_files, :path_file_list, :to_test_task
+    should have_instance_methods :test_tasks, :scopes
+
+    should "know its the test file suffix" do
+      assert_equal "_test.rb", subject.class.test_file_suffix
+    end
+
+    should "know its namespace" do
+      assert_equal :test_root, subject.namespace
+      assert_equal :shallow, Assert::RakeTasks::Scope.new(File.join(@scope_root, 'test_root/shallow')).namespace
+    end
+
+    should "know its nested files" do
+      assert_equal 6, subject.nested_files.size
+      assert_empty Assert::RakeTasks::Scope.new('does/not/exist').nested_files
+
+      h = Assert::RakeTasks::Scope.new("#{@scope_root}/test_root/shallow")
+      assert_equal 2, h.nested_files.size
+    end
+
+    should "know its path file" do
+      assert_empty subject.path_file_list
+
+      h = Assert::RakeTasks::Scope.new("#{@scope_root}/test_root/shallow")
+      assert_equal 1, h.path_file_list.size
+    end
+
+    should "convert to a test task" do
+      assert_not Assert::RakeTasks::Scope.new('does/not/exist').to_test_task
+
+      tt = subject.to_test_task
+      assert_kind_of TestTask, tt
+      assert_equal subject.nested_files.size+subject.path_file_list.size, tt.files.size
+    end
+
+    should "have a test task for each standalone test file" do
+      assert_equal 2, subject.test_tasks.size
+      assert_kind_of TestTask, subject.test_tasks.first
+    end
+
+    should "have a scope for each immediate test dir or test dir/file in the scope" do
+      assert_equal 2, subject.scopes.size
+      assert_kind_of Scope, subject.scopes.first
+    end
+
+  end
+
+end

data/test/rake_tasks/test_task_test.rb

@@ -0,0 +1,80 @@
+require 'assert'
+
+require 'assert/rake_tasks/test_task'
+
+module Assert::RakeTasks
+
+  class TestTaskTests < Assert::Context
+    desc "the test task"
+    setup do
+      @task = Assert::RakeTasks::TestTask.new('thing')
+      @some_thing = Assert::RakeTasks::TestTask.new('test/some/thing')
+    end
+    subject { @task }
+
+    should have_accessors :path, :files
+    should have_instance_methods :relative_path, :scope_description, :description, :name
+    should have_instance_methods :file_list, :ruby_args, :show_loaded_files?
+
+    should "default with empty files collection" do
+      assert_equal [], subject.files
+    end
+
+    should "know its relative path" do
+      assert_equal "", subject.relative_path
+      assert_equal "some/thing", @some_thing.relative_path
+    end
+
+    should "know its scope description" do
+      assert_equal "", subject.scope_description
+      assert_equal " for some/thing", @some_thing.scope_description
+    end
+
+    should "know its task description" do
+      assert_equal "Run all tests", subject.description
+      assert_equal "Run all tests for some/thing", @some_thing.description
+    end
+
+    should "know its name" do
+      assert_equal :thing, @task.name
+      assert_equal :thing, @some_thing.name
+    end
+
+    should "build a file list string" do
+      subject.files = ["test_one_test.rb", "test_two_test.rb"]
+      assert_equal "\"test_one_test.rb\" \"test_two_test.rb\"", subject.file_list
+    end
+
+    should "know its ruby args" do
+      subject.files = ["test_one_test.rb", "test_two_test.rb"]
+      assert_equal "-rrubygems \"#{subject.send(:rake_loader)}\" #{subject.file_list}", subject.ruby_args
+    end
+
+  end
+
+  class VerboseTests < TestTaskTests
+    setup do
+      @orig_env_setting = ENV["show_loaded_files"]
+      ENV["show_loaded_files"] = 'false'
+    end
+    teardown do
+      ENV["show_loaded_files"] = @orig_env_setting
+    end
+
+    should "not show loaded files by default" do
+      assert_equal false, subject.show_loaded_files?
+    end
+  end
+
+  class EnvVerboseTests < VerboseTests
+    desc "if the show_loaded_files env setting is true"
+    setup do
+      ENV["show_loaded_files"] = 'true'
+    end
+
+    should "show loaded files" do
+      assert_equal true, subject.show_loaded_files?
+    end
+  end
+
+end

data/test/result_set_test.rb

@@ -37,13 +37,13 @@ class Assert::ResultSet
       @view_s = ""
       @view = @result_set.view = FakeView.new(nil, StringIO.new(@view_s, "w+"))
 
-      @pass_result = Assert::Result::Pass.new("test", "pass", [])
+      @pass_result = Assert::Result::Pass.new(Factory.test("test"), "pass", [])
       @result_set << @pass_result
-      @fail_result = Assert::Result::Fail.new("test", "fail", [])
+      @fail_result = Assert::Result::Fail.new(Factory.test("test"), "fail", [])
       @result_set << @fail_result
-      @skip_result = Assert::Result::Skip.new("test", RuntimeError.new)
+      @skip_result = Assert::Result::Skip.new(Factory.test("test"), Assert::Result::TestSkipped.new)
       @result_set << @skip_result
-      @error_result = Assert::Result::Error.new("test", RuntimeError.new)
+      @error_result = Assert::Result::Error.new(Factory.test("test"), RuntimeError.new)
       @result_set << @error_result
     end
     subject{ @view }

data/test/result_test.rb

@@ -31,12 +31,13 @@ module Assert::Result
   class BaseTest < Assert::Context
     desc "a base result"
     setup do
-      @result = Assert::Result::Base.new("a test name", "a message", ["line 1", "line2"])
+      @test = Factory.test("a test name")
+      @result = Assert::Result::Base.new(@test, "a message", ["line 1", "line2"])
     end
     subject{ @result }
 
-    should have_readers :test_name, :message, :backtrace
-    should have_instance_methods :to_sym, :to_s, :trace
+    should have_readers :test, :message, :backtrace
+    should have_instance_methods :test_name, :name, :to_sym, :to_s, :trace
 
     Assert::Result.types.keys.each do |type|
       should "respond to the instance method ##{type}?" do
@@ -48,8 +49,12 @@ module Assert::Result
       end
     end
 
+    should "know its test" do
+      assert_equal @test, subject.test
+    end
+
     should "nil out empty messages" do
-      assert_equal nil, Assert::Result::Base.new("a test name", "").message
+      assert_equal nil, Assert::Result::Base.new(@test, "").message
     end
 
     should "show only its class and message when inspected" do
@@ -83,7 +88,8 @@ module Assert::Result
   class PassTest < Assert::Context
     desc "a pass result"
     setup do
-      @result = Assert::Result::Pass.new("test", "passed", [])
+      @test = Factory.test("a test name")
+      @result = Assert::Result::Pass.new(@test, "passed", [])
     end
     subject { @result }
 
@@ -98,7 +104,11 @@ module Assert::Result
     end
 
     should "know its to_sym" do
-      assert_equal :passed, subject.to_sym
+      assert_equal :pass, subject.to_sym
+    end
+
+    should "know its name" do
+      assert_equal "Pass", subject.name
     end
 
     should "include PASS in its to_s" do
@@ -106,73 +116,74 @@ module Assert::Result
     end
   end
 
-  class FailTest < Assert::Context
-    desc "a fail result"
+  class IgnoreTest < Assert::Context
+    desc "an ignore result"
     setup do
-      @result = Assert::Result::Fail.new("test", "failed", [])
+      @test = Factory.test("a test name")
+      @result = Assert::Result::Ignore.new(@test, "ignored", [])
     end
     subject { @result }
 
-    should "be fail?" do
-      assert_equal true, subject.fail?
+    should "be ignore?" do
+      assert_equal true, subject.ignore?
     end
 
-    Assert::Result.types.keys.reject{|k| k == :fail}.each do |type|
+    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 :failed, subject.to_sym
+      assert_equal :ignore, subject.to_sym
     end
 
-    should "include FAIL in its to_s" do
-      assert subject.to_s.include?("FAIL")
+    should "know its name" do
+      assert_equal "Ignore", subject.name
+    end
+
+    should "include IGNORE in its to_s" do
+      assert subject.to_s.include?("IGNORE")
     end
   end
 
-  class IgnoreTest < Assert::Context
-    desc "an ignore result"
+  class FailureRuntimeErrorTest < Assert::Context
+
+    should "be a runtime error" do
+      assert_kind_of RuntimeError, Assert::Result::TestFailure.new
+    end
+
+  end
+
+  class FailTest < Assert::Context
+    desc "a fail result"
     setup do
-      @result = Assert::Result::Ignore.new("test", "ignored", [])
+      @test = Factory.test("a test name")
+      @result = Assert::Result::Fail.new(@test, "failed", [])
     end
     subject { @result }
 
-    should "be ignore?" do
-      assert_equal true, subject.ignore?
+    should "be fail?" do
+      assert_equal true, subject.fail?
     end
 
-    Assert::Result.types.keys.reject{|k| k == :ignore}.each do |type|
+    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 :ignored, subject.to_sym
-    end
-
-    should "include IGNORE in its to_s" do
-      assert subject.to_s.include?("IGNORE")
+      assert_equal :fail, subject.to_sym
     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)
+    should "know its name" do
+      assert_equal "Fail", subject.name
     end
-    subject{ @result }
 
-    should "have the same backtrace as the original exception it was created from" do
-      assert_equal @exception.backtrace, subject.backtrace
+    should "include FAIL in its to_s" do
+      assert subject.to_s.include?("FAIL")
     end
-
   end
 
   class SkippedRuntimeErrorTest < Assert::Context
@@ -183,10 +194,17 @@ module Assert::Result
 
   end
 
-  class SkipTest < FromExceptionTest
+  class SkipTest < Assert::Context
     desc "a skip result"
     setup do
-      @result = Assert::Result::Skip.new("test", @exception)
+      @test = Factory.test("a test name")
+      @exception = nil
+      begin
+        raise TestSkipped, "test ski["
+      rescue Exception => err
+        @exception = err
+      end
+      @result = Assert::Result::Skip.new(@test, @exception)
     end
     subject { @result }
 
@@ -201,7 +219,11 @@ module Assert::Result
     end
 
     should "know its to_sym" do
-      assert_equal :skipped, subject.to_sym
+      assert_equal :skip, subject.to_sym
+    end
+
+    should "know its name" do
+      assert_equal "Skip", subject.name
     end
 
     should "include SKIP in its to_s" do
@@ -209,10 +231,17 @@ module Assert::Result
     end
   end
 
-  class ErrorTest < FromExceptionTest
+  class ErrorTest < Assert::Context
     desc "an error result"
     setup do
-      @result = Assert::Result::Error.new("test", @exception)
+      @test = Factory.test("a test name")
+      @exception = nil
+      begin
+        raise Exception, "test error"
+      rescue Exception => err
+        @exception = err
+      end
+      @result = Assert::Result::Error.new(@test, @exception)
     end
     subject { @result }
 
@@ -227,7 +256,11 @@ module Assert::Result
     end
 
     should "know its to_sym" do
-      assert_equal :errored, subject.to_sym
+      assert_equal :error, subject.to_sym
+    end
+
+    should "know its name" do
+      assert_equal "Error", subject.name
     end
 
     should "include ERRORED in its to_s" do

data/test/suite/context_info_test.rb

@@ -0,0 +1,42 @@
+require 'assert'
+
+class Assert::Suite::ContextInfo
+
+  class BasicTests < Assert::Context
+    desc "a suite's context info"
+    setup do
+      @caller = caller
+      @klass = Assert::Context
+      @info = Assert::Suite::ContextInfo.new(@klass, @caller.first)
+    end
+    subject { @info }
+
+    should have_readers :klass, :called_from, :file
+
+    should "set its klass on init" do
+      assert_equal @klass, subject.klass
+    end
+
+    should "set its called_from to the first caller on init" do
+      assert_equal @caller.first, subject.called_from
+    end
+
+    should "set its file from caller info on init" do
+      assert_equal @caller.first.gsub(/\:[0-9]+.*$/, ''), subject.file
+    end
+
+  end
+
+  class KlassOnlyTests < BasicTests
+    desc "w/ only klass information"
+    setup do
+      @info = Assert::Suite::ContextInfo.new(@klass)
+    end
+
+    should "not have any file info" do
+      assert_nil subject.file
+    end
+
+  end
+
+end

data/test/suite_test.rb

@@ -16,25 +16,14 @@ class Assert::Suite
     end
     subject { @suite }
 
-    should have_instance_method  :<<
-    should have_instance_methods :contexts, :tests, :ordered_tests, :ordered_results
+    should have_instance_methods :ordered_tests, :results, :ordered_results
     should have_instance_methods :count, :test_count, :result_count
     should have_instance_methods :setup, :startup, :teardown, :shutdown
 
+    should have_accessors :tests, :test_methods
     should have_accessors :start_time, :end_time
     should have_instance_method  :run_time, :runner_seed
 
-    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", "test_repeated"].sort,
@@ -53,26 +42,26 @@ class Assert::Suite
     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
+      @suite.tests = [
+        Factory.test("should do nothing", Factory.context_info(context_class)),
+        Factory.test("should pass", Factory.context_info(context_class)) do
           assert(1==1)
           refute(1==0)
         end,
-        Factory.test("should fail", context_class) do
+        Factory.test("should fail", Factory.context_info(context_class)) do
           ignore
           assert(1==0)
           refute(1==1)
         end,
-        Factory.test("should be ignored", context_class) do
+        Factory.test("should be ignored", Factory.context_info(context_class)) do
           ignore
         end,
-        Factory.test("should skip", context_class) do
+        Factory.test("should skip", Factory.context_info(context_class)) do
           skip
           ignore
           assert(1==1)
         end,
-        Factory.test("should error", context_class) do
+        Factory.test("should error", Factory.context_info(context_class)) do
           raise Exception
           ignore
           assert(1==1)
@@ -167,32 +156,6 @@ class Assert::Suite
   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
-
-
 
   class SetupTest < Assert::Context
     desc "a suite with a setup"