test4requirements 0.1.0.alpha.2

data/lib/test4requirements/shoulda.rb

@@ -0,0 +1,77 @@
+=begin rdoc
+Support of shoulda.
+
+Details on usage see examples/example_test4requirements_shoulda.rb
+
+Fixmes: 
+* should_not is not supported yet
+=end
+
+require_relative '../test4requirements'
+require 'shoulda' #tested with shoulda 2.11.3
+
+#
+module Test
+  module Unit
+    class TestCase
+      class << self
+        #remember original definition.
+        alias  :should_old :should
+=begin rdoc
+Extend #should to support assignment to requirement.
+
+Usage:
+  should 'fullfill request 1', requirement: :req1  do
+    assert_equal(2,1+1)
+  end
+=end
+        def should(name_or_matcher, options = {}, &blk)
+          if ! self.name
+            raise RuntimeError, "Shoulda not defined for anonymous classes"
+          end
+          if options[:requirement]
+            #testmethodname must fit self.name of the later test (TestCase#run_test)
+            testmethodname = 'test: '
+            testmethodname << self.name.gsub(/Test/, "")
+            testmethodname << ' should '
+            testmethodname << name_or_matcher
+            testmethodname << '. '
+            testmethodname << "(#{self.name})"
+            raise RuntimeError, "No requirements defined for #{self}" unless get_requirements
+            get_requirements.assign_test(options[:requirement], testmethodname)
+          end
+          should_old(name_or_matcher, options = {}, &blk)
+        end #should
+      end #eigenclass TestCase
+    end #class TestCase
+  end #module Unit
+end   #module Test
+
+module Shoulda
+  class Context
+      #remember original definition.
+      alias  :should_old :should
+=begin rdoc
+Extend #should inside a context to support assignment to requirement.
+
+Usage:
+  should 'fullfill request 1', requirement: :req1  do
+    assert_equal(2,1+1)
+  end
+=end
+      def should(name_or_matcher, options = {}, &blk)
+        if options[:requirement]
+          #testmethodname must fit self.name of the later test (TestCase#run_test)
+          testmethodname = 'test: '
+          testmethodname << self.name
+          testmethodname << ' should '
+          testmethodname << name_or_matcher
+          testmethodname << '. '
+          testmethodname << "(#{self.parent.name})"
+          raise RuntimeError, "No requirements defined for #{self}" unless get_requirements
+          get_requirements.assign_test(options[:requirement], testmethodname)
+        end
+        should_old(name_or_matcher, options = {}, &blk)
+      end #should
+  end# class Context
+end #Shoulda

data/lib/test4requirements/testcase.rb

@@ -0,0 +1,59 @@
+=begin rdoc
+Extend TestCase to handle requirements.
+=end
+gem 'test-unit' 
+require 'test/unit'
+
+#
+module Test
+  module Unit
+    class TestCase
+      class << self
+=begin rdoc
+Define requirements, handled by the TestCase-object.
+=end
+        def requirements=(req)
+          raise ArgumentError, "#{self.class}: Expected RequirementList, received #{req.inspect}" unless req.is_a?(Test4requirements::RequirementList)
+          raise ArgumentError, "#{self.class}: Get two RequirementLists" if defined? @requirements
+          @requirements = req
+        end
+        #for usage inside class definition.
+        alias :requirements :'requirements='
+        
+        def get_requirements; @requirements; end
+    end #eigenclass TestCase
+=begin rdoc
+Get Requirements for TestCases
+=end
+    def requirements
+      self.class.get_requirements
+    end
+=begin rdoc
+Assign a requirement.
+To be called inside a test_*-method.
+
+Example:
+    def test_1()
+      assign_requirement(:req1)  #this test is testing requirement 1
+      assert_equal(2,1+1)
+    end
+=end      
+      def assign_requirement(req)
+        raise RuntimeError, "No requirements defined for #{self}" unless requirements
+        requirements.assign_test(req, self.name)
+      end
+      alias  :run_test_old :run_test
+=begin rdoc
+Add info about a successfull test to the assigned requirement.
+=end
+      def run_test
+        run_test_old
+        #this code is left if a problem occured.
+        #in other words: if we reach this place, then the test was sucesfull
+        if requirements
+          requirements.test_successfull(self.name)
+        end #if requirements
+      end #def run_test
+    end #class TestCase
+  end #module Unit
+end   #module Test

data/unittest/check_compatibility.rb

@@ -0,0 +1,65 @@
+=begin rdoc
+Some check routines to check the installation
+=end
+
+puts RUBY_DESCRIPTION
+
+
+gem 'test-unit'
+#~ require 'test/unit'
+require 'test/unit/version'
+
+=begin rdoc
+
+Encoding#ascii_compatible?
+
+Test::Unit::Assertions contains:
+            if string.respond_to?(:encoding) and
+                !string.encoding.ascii_compatible?
+              string = string.dup.force_encoding("ASCII-8BIT")
+            end
+Probably added with test-unit 2.2.0
+http://rubyforge.org/forum/forum.php?forum_id=38792
+   support not ASCII compatible string diff.
+   
+Encoding#ascii_compatible? was added with:     
+http://redmine.ruby-lang.org/issues/show/1900
+Applied in changeset r24480.
+
+http://www.ruby-forum.com/topic/192885
+
+
+=end
+if Test::Unit::VERSION >= '2.3.1'
+    if ! 'string'.encoding.respond_to?(:'ascii_compatible?')
+      puts "Encoding#ascii_compatible? not defined - Test::Unit #{Test::Unit::VERSION} needs it"
+    end
+end
+
+#~ gem 'test-unit', '= 2.3.1'
+#~ require 'test/unit' 
+#~ class Test_Requirement < Test::Unit::TestCase
+  #~ def test_interface_ok()
+    #~ assert_equal('a', 'b')
+  #~ end
+#~ end
+  
+
+__END__
+RUBY_VERSION 
+RUBY_PATCHLEVEL
+RUBY_RELEASE_DATE
+
+Worked fine:
+gem 'test-unit', '= 2.1.1'
+
+
+gem 'test-unit', '= 2.3.1'
+ruby 1.9.1
+
+
+            if string.respond_to?(:encoding) and
+                !string.encoding.ascii_compatible?
+              string = string.dup.force_encoding("ASCII-8BIT")
+            end
+

data/unittest/unittest_requirement.rb

@@ -0,0 +1,82 @@
+$:.unshift('../lib')
+gem 'test-unit'
+require 'test/unit'
+require 'test4requirements/requirement.rb'
+include Test4requirements
+
+class Test_Requirement < Test::Unit::TestCase
+  
+  def test_interface_ok()
+    req = nil
+    assert_nothing_raised { req = Requirement.new(1) }
+    assert_equal(1, req.key)
+  end
+  def test_interface_empty()    
+    assert_raise(ArgumentError) { Requirement.new() }
+  end
+  def test_interface_option_description()
+    req = nil
+    assert_nothing_raised { req = Requirement.new(1, :description => 'desc')}
+    assert_equal('desc', req.description)
+  end
+  def test_interface_option_reference()
+    req = nil
+    assert_nothing_raised { req = Requirement.new(1, :reference => 'ref')}
+    assert_equal('ref', req.reference)
+  end  
+  def test_interface_option()
+    assert_raise(ArgumentError) { Requirement.new(1, :undefined_key => 'desc') }
+  end
+  
+  def test_no_test_assignment()
+    req = Requirement.new(1)
+    assert_false(req.tested?)
+    assert_nil(req.successfull?)
+  end
+
+  def test_test_assignment()
+    req = Requirement.new(1)
+    req.test='loc'
+    assert_equal(1,req.tested?)
+    req.test='loc'
+    assert_equal(1,req.tested?, "No duplicate definition")
+    req.test='loc2'
+    assert_equal(2,req.tested?, "Two TestCases")
+    
+    assert_false(req.successfull?)
+  end
+
+  def test_test_success()
+    req = Requirement.new(1)
+    req.test='loc'
+    assert_equal(1,req.tested?)
+    assert_false(req.successfull?)
+    
+    req.successfull_test('loc')
+    assert_equal(1,req.tested?)
+    assert_true(req.successfull?)
+  end
+
+  def test_test_success_without_assignment()
+    req = Requirement.new(1)
+    assert_false(req.tested?)
+    assert_nil(req.successfull?)
+    
+    req.successfull_test('loc')
+    assert_equal(1,req.tested?)
+    assert_true(req.successfull?)
+  end
+
+  def test_2test_success()
+    req = Requirement.new(1)
+    req.test='loc'
+    assert_equal(1,req.tested?)
+    assert_false(req.successfull?)
+    
+    req.successfull_test('loc2')
+    assert_equal(2,req.tested?)
+    assert_false(req.successfull?, "One of the tests was unsuccessfull")
+  end
+
+  
+end

data/unittest/unittest_requirementlist.rb

@@ -0,0 +1,84 @@
+$:.unshift('../lib')
+gem 'test-unit'
+require 'test/unit'
+require 'log4r'
+
+require 'test4requirements/requirement.rb'
+require 'test4requirements/requirementlist.rb'
+include Test4requirements
+
+RequirementList.report_type_default = nil
+
+
+class Test_RequirementList < Test::Unit::TestCase
+  
+  def test_interface()
+    assert_nothing_raised { RequirementList.new()}
+    assert_nothing_raised { RequirementList.new(1)}
+    assert_nothing_raised { RequirementList.new(Requirement.new(1))}
+  end
+  
+  def test_add_requirement()
+    req = RequirementList.new()
+    assert_nothing_raised { req << Requirement.new(1) }
+    assert_raise(ArgumentError) { req << 1 }
+  end
+  
+  def test_interface_double_definition()
+    assert_raise(ArgumentError) { RequirementList.new(1, 1) }
+    assert_raise(ArgumentError) { RequirementList.new(Requirement.new(1),1)}
+    assert_raise(ArgumentError) { RequirementList.new(Requirement.new(1),Requirement.new(1))}
+  end
+  
+  def test_unassigned_test()
+    req = RequirementList.new()
+    assert_raise(ArgumentError, "Unkwown req. can't be assigned") { req.assign_test(1, 'loc')}
+    assert_equal(nil, req[1], "Unassigned test returns nil")
+    #~ assert_false(req[1].tested?)
+    #~ assert_false(req[1].successfull?)
+  end
+  def test_assign_test()
+    req = RequirementList.new()
+    assert_nothing_raised("Assign requirement") { req << Requirement.new(1) }
+    assert_nothing_raised("Assign test") { req.assign_test(1, 'loc') }
+    assert_instance_of(Requirement, req[1])
+    assert_equal(false, req[1]['loc'])
+    assert_equal(1,req[1].tested?)
+    assert_false(req[1].successfull?)
+  end
+
+  def test_successfull_test()
+    req = RequirementList.new()
+    req << Requirement.new(1)
+    req.assign_test(1, 'loc')  #not neccesary
+    assert_false(req[1]['loc'])
+    
+    assert_nothing_raised("Successfull test") { req.test_successfull('loc') }
+    assert_instance_of(Requirement, req[1])
+    assert_equal(1,req[1].tested?)
+    assert_true(req[1]['loc'])
+    assert_true(req[1].successfull?)
+  end
+  
+  def test_successfull_test_without_assignment()
+    req = RequirementList.new()
+    req << Requirement.new(1)
+    
+    assert_nothing_raised("Successfull test") { req.test_successfull('loc') }
+    assert_instance_of(Requirement, req[1])
+    assert_false(req[1].tested?)
+    assert_nil(req[1].successfull?)
+  end
+  
+  def test_unsuccessfull_test()
+    req = RequirementList.new()
+    req << Requirement.new(1)
+    req.assign_test(1, 'loc') 
+    assert_instance_of(Requirement, req[1])
+    assert_equal(false, req[1]['loc'])
+    assert_equal(1,req[1].tested?)
+    assert_false(req[1].successfull?)
+  end
+
+end
+

data/unittest/unittest_requirementlist_overview.rb

@@ -0,0 +1,199 @@
+$:.unshift('../lib')
+#~ gem 'test-unit'
+#~ require 'test/unit'
+require 'test4requirements.rb'
+include Test4requirements
+
+RequirementList.report_type_default = nil
+
+#IO to catch stdout in TestRunner
+IO_Catcher = Class.new(IO){ def write(arg);end }.new(2, 'w')  
+
+class Test_RequirementList_Overview_without_test < Test::Unit::TestCase
+  def setup
+    @reqs = RequirementList.new(1,2,3)
+    @testcase = Class.new(Test::Unit::TestCase)
+    @testcase.requirements=  @reqs
+    #~ @testcase.suite() #run tests
+  end
+  
+  def test_overview_default()
+    assert_kind_of(Hash, @reqs.overview)
+    assert_equal([1,2,3], @reqs.overview.keys)
+    @reqs.overview.each{|key,req| assert_nil(req) }
+  end
+
+  #same as default
+  def test_overview_nil()
+    @reqs.report_type = nil
+    assert_kind_of(Hash, @reqs.overview)
+    assert_equal([1,2,3], @reqs.overview.keys)
+  end
+
+  def test_overview_txt()
+    @reqs.report_type = :txt
+    assert_kind_of(Array, @reqs.overview)
+    assert_equal(3, @reqs.overview.size)
+    assert_equal(["Requirement 1 was not tested",
+                       "Requirement 2 was not tested",
+                       "Requirement 3 was not tested"], @reqs.overview)
+  end
+
+  def test_overview_unknown()
+    assert_raise(ArgumentError){@reqs.report_type = :unknown}
+    assert_nothing_raised{@reqs.overview}
+    assert_raise(ArgumentError){@reqs.overview(:unknown)}
+  end
+end
+
+
+class Test_RequirementList_Overview_with_test < Test::Unit::TestCase
+  def setup
+    @reqs = RequirementList.new(:req1,:req2,:req3)
+    @testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      
+      def test_1()
+        assign_requirement(:req1)  #this test is testing requirement req1
+        assert_equal(2,1+1)
+      end
+      def test_2()
+        assign_requirement(:req2)  #this test is testing requirement req2 without success
+        assert_equal(3,1+1)
+      end
+    end
+    @testcase.requirements=  @reqs
+    
+    suite = @testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  
+  def test_testcase_definition()
+    assert_true(@testcase.instance_methods.include?(:test_1))
+    assert_true(@testcase.instance_methods.include?(:test_2))
+    #~ assert_true(@testcase.respond_to?(:test_1))
+    #~ assert_true(@testcase.respond_to?(:test_2))
+  end
+  
+  def test_overview_default()
+    assert_kind_of(Hash, @reqs.overview)
+    assert_equal([:req1,:req2,:req3], @reqs.overview.keys)
+    assert_equal([true,false,nil], @reqs.overview.values)
+  end
+
+  #same as default
+  def test_overview_nil()
+    @reqs.report_type = nil
+    assert_kind_of(Hash, @reqs.overview)
+    assert_equal([true,false,nil], @reqs.overview.values)
+  end
+
+  def test_overview_txt()
+    @reqs.report_type = :txt
+    assert_kind_of(Array, @reqs.overview)
+    assert_equal(3, @reqs.overview.size)
+    assert_equal(["Requirement req1 was successfull tested (test_1(Test_ReqList))",
+                       "Requirement req2 was unsuccessfull tested (test_2(Test_ReqList))",
+                       "Requirement req3 was not tested"
+                    ], @reqs.overview)
+  end
+end
+
+
+
+class Test_two_tests_for_one_requirement_successfull  < Test::Unit::TestCase
+  def setup
+    @reqs = reqs = RequirementList.new(:req1)
+    testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      self.requirements=  reqs
+      
+      def test_1()
+        assign_requirement(:req1)  #this test is testing requirement req1
+        assert_equal(2,1+1)
+      end
+      def test_2()
+        assign_requirement(:req1)  #this test is testing requirement req2 without success
+        assert_equal(2,1+1)
+      end
+    end
+    
+    suite = testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  def test_duplicate_test  
+    assert_equal([:req1], @reqs.overview.keys)
+    assert_equal([true], @reqs.overview.values)
+  end
+  def test_overview_txt()
+    @reqs.report_type = :txt  
+     assert_equal(["Requirement req1 was successfull tested (test_1(Test_ReqList), test_2(Test_ReqList))",], @reqs.overview)   
+  end
+end
+
+class Test_two_tests_for_one_requirement_unsuccessfull < Test::Unit::TestCase
+  def setup
+    @reqs = reqs = RequirementList.new(:req1)
+    testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      self.requirements=  reqs
+      #Unsuccessfull
+      def test_1()
+        assign_requirement(:req1)  #this test is testing requirement req1
+        assert_equal(3,1+1)
+      end
+      #Unsuccessfull
+      def test_2()
+        assign_requirement(:req1)  #this test is testing requirement req2 without success
+        assert_equal(3,1+1)
+      end
+    end
+    
+    suite = testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  def test_duplicate_test  
+    assert_equal([:req1], @reqs.overview.keys)
+    assert_equal([false], @reqs.overview.values)
+  end
+  def test_overview_txt()
+    @reqs.report_type = :txt  
+     assert_equal(["Requirement req1 was unsuccessfull tested (test_1(Test_ReqList), test_2(Test_ReqList))",], @reqs.overview)   
+  end
+end
+
+class Test_two_tests_for_one_requirement_mixed_result < Test::Unit::TestCase
+  def setup
+    @reqs = reqs = RequirementList.new(:req1)
+    testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      self.requirements=  reqs
+      #Successfull
+      def test_1()
+        assign_requirement(:req1)  #this test is testing requirement req1
+        assert_equal(2,1+1)
+      end
+      #Unsuccessfull
+      def test_2()
+        assign_requirement(:req1)  #this test is testing requirement req2 without success
+        assert_equal(3,1+1)
+      end
+    end
+    
+    suite = testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  def test_duplicate_test  
+    assert_equal([:req1], @reqs.overview.keys)
+    assert_equal([false], @reqs.overview.values)
+  end
+  def test_overview_txt()
+    @reqs.report_type = :txt  
+     assert_equal(["Requirement req1 was unsuccessfull tested (OK: test_1(Test_ReqList), Failure: test_2(Test_ReqList))",], @reqs.overview)   
+  end
+end
+