test4requirements 0.1.0.alpha.2 → 0.1.0

data/lib/test4requirements/requirement.rb

@@ -1,6 +1,5 @@
 =begin rdoc
 Define a requirement.
-
 =end
 module Test4requirements
   class Requirement
@@ -8,19 +7,24 @@ module Test4requirements
     OPTIONS = [
       :description,
       :reference,
+      :key, #optional, but must be identic with first parameter
     ]
 =begin rdoc
 Each requirement must include a key.
 
 Optional values:
 * description
-* reference
+* reference, e.g. 'Customer Requirement, Version 2011-08-02, page 12'
+
 =end
     def initialize( key, options = {} )
+      
       @key = key
       options.keys.each{|key|
-        raise ArgumentError, "Key #{key} undefined" unless OPTIONS.include?(key)
+        raise ArgumentError, "#{self.class}.new: Option #{key} undefined" unless OPTIONS.include?(key)
       }
+      raise ArgumentError, "#{self.class}.new: Key not explicit: #{key}" if options[:key] and options[:key]  != key
+      
       @description = options[:description]
       @reference = options[:reference]
       
@@ -36,8 +40,16 @@ Optional values:
     attr_reader :reference
     #Logger. Defined by RequirementList#<<
     attr_accessor :log
+    #Testcases of the requirement
+    attr_reader :tests
 
-
+=begin rdoc  
+Assign a TestCase.
+=end
+    def test=(loc)
+      @log.info("Test #{loc} assigned to requirement #{@key}") if @log and @log.info?
+      @tests[loc] = []  #Collects problems
+    end
 =begin rdoc
 Returns the result of a TestCase.
 
@@ -46,46 +58,38 @@ Returns the result of a TestCase.
 * true: Succesfull tested
 =end
     def [](key)
-      @tests[key]
+      return nil unless @tests[key]
+      return @tests[key].uniq == [:ok]
     end
-
 =begin rdoc  
-Assign a TestCase.
+Set a result for a test case.
 =end
-    def test=(loc)
-      @log.info("Test #{loc} assigned to requirement #{@key}") if @log and @log.info?
-      @tests[loc] = false   #Will be tested
-    end
-
-=begin rdoc  
-Mark a test as successfull.
-=end
-    def successfull_test(loc)
-      #fixme: Check if already defined?
-      #~ raise ArgumentError, "Successfull test #{loc} was never assigned" unless @tests.has_key?(loc)
-      @log.info("Test #{loc} successfull for to requirement #{@key}") if @log and @log.info?
-      @tests[loc] = true #Was successfull tested
+    def result(key, val)      
+      @tests[key] ||= []
+      @tests[key] << val
     end
+    
 =begin rdoc
 Return false, if no test is defined.
 Else you get the number of tests.
 =end
-    def tested?()
+    def test_defined?()
       return @tests.empty? ? false : @tests.size
     end
 =begin rdoc
 Test, if the requirement was successfull.
 
 If there is one test without success, the requirement is not successfull solved.
-* nil: no test found
+* nil: no test found or one test not executed
 * false: At least one test not successfull
 * true: Succesfull tested
 =end
     def successfull?()
-      return nil if @tests.empty?
+      return nil unless test_defined?
       success = true
       @tests.each{|key,result|
-        success = (success and result)
+        return nil if result.empty?
+        success = (success and (result - [:ok]).empty?)
       }
       return success
     end
@@ -96,7 +100,10 @@ Return a list of tests with test result.
       #single tests: Only key returned
       #~ return @tests.keys if @tests.size == 1
       res_ok = []
-      res_err = []
+      res_fail = []
+      res_pend = []
+      res_omit = []
+      res_error = []  #enclear erros status
       @tests.each{|key, result|
         #Convert key (for shoulda)
         case key
@@ -106,20 +113,27 @@ Return a list of tests with test result.
             key = "#{$2} (#{$1}/#{$3})"
         end
       
-        if result
+        if result.include?(:failure)
+          res_fail << key
+        elsif result.include?(:pend)
+          res_pend << key
+        elsif result.include?(:omit)
+          res_omit << key
+        elsif result.include?(:ok)
           res_ok << key
         else
-          res_err << key
+          res_error << key
         end
+
       }
-      #return filled array, if other array is empty
-      return res_ok if res_err.empty?
-      return res_err if res_ok.empty?
       
-      [
-        "OK: #{res_ok.join(', ')}", 
-        "Failure: #{res_err.join(', ')}",
-      ]
+      res = []
+      res << "OK: #{res_ok.join(', ')}"  unless res_ok.empty?
+      res << "Failure: #{res_fail.join(', ')}"  unless res_fail.empty?
+      res << "Pending: #{res_pend.join(', ')}" unless res_pend.empty?
+      res << "Omission: #{res_omit.join(', ')}" unless res_omit.empty?
+      res << "Error: #{res_omit.join(', ')}"  unless res_error.empty?
+      res 
     end
     
     def to_s()
@@ -129,4 +143,11 @@ Return a list of tests with test result.
       #~ "<Requirement #{key} #{@tests}>"
     #~ end
   end
-end #module Test4requirements
+end #module Test4requirements
+
+__END__
+    req = Test4requirements::Requirement.new(1)
+    req.test='loc'
+    req.result('loc',:ok)
+    p req.test_defined?
+    p req.successfull?

data/lib/test4requirements/requirementlist.rb

@@ -15,14 +15,42 @@ This class can be used in Test::Unit::TestCase#assign_requirement.
 =begin rdoc
 Define a list of requirements.
 
-Parameters will define the key of new Requirement, unless it is no Requirement.
+Parameters:
+* name
+* list of requirement (keys)
+* options
+  * :requirements
+  * :log Define a logger
+
+The list of requirements will define the key of a new Test4requirements::Requirement, 
+unless it is already a Test4requirements::Requirement.
+
+Examples:
+  RequirementList.new('Request_4711')
+  RequirementList.new('Request_4711', :req1, :req2 )
+  RequirementList.new('Request_4711', Reqirement.new(:req1), Reqirement.new(:req2) )
+  RequirementList.new('Request_4711', 
+      :requirements => [ :req1, :req2]
+    )
+  RequirementList.new('Request_4711', 
+      Reqirement.new(:req1), Reqirement.new(:req2),
+      :requirements => [ :req3, :req4]
+    )
+    
 =end
-    def initialize( *reqs )
+    def initialize( name, *args )
       
-      @log = Log4r::Logger.new('ReqL')
+      options = {
+        :log => Log4r::Logger.new('ReqL'),
+        :requirements => [],
+        }.merge( args.last.is_a?(Hash) ? args.pop : {} )
+      options[:requirements].concat(args)
+      
+      @name = name
+      @log = options[:log]
       
       @requirements = {}
-      reqs.each{|req|
+      options[:requirements].each{|req|
       
         #Define a requirement.
         if ! req.is_a?(Requirement)
@@ -31,7 +59,8 @@ Parameters will define the key of new Requirement, unless it is no Requirement.
 
         self << req
       }
-      
+      @testsresults = []
+
       #Yes, we need two at_exit.
       #tests are done also at_exit.  With double at_exit, we are after that.
       #Maybe better to be added later.
@@ -42,8 +71,13 @@ Parameters will define the key of new Requirement, unless it is no Requirement.
       }
       @report_type = self.class.report_type_default # alternatives: nil, :stdout, :txt
     end #initialize
+    #Name or ID of the requirement list.
+    attr_reader :name
     #Logger
     attr_reader :log
+    #List of related result objects Test::Unit::TestResult (one per suite, normally only 1)
+    attr_reader :testsresults
+    
 =begin rdoc
 Add a new requirement.
 =end
@@ -57,32 +91,67 @@ Add a new requirement.
       @requirements[req.key] = req
     end
 =begin rdoc
+Method to load requirements.
+
+You can provide:
+* an array of hashes with requirement definition
+* a hash with key and requirement definition
+
+The requirement definition can contain the options of Test4requirements::Requirement.
+
+You may use yaml to define your requirments:
+  req = RequirementList.new('Requirementlist')
+  req.load( YAML.load( <<yaml
+        req1:
+          description: 'What is required',
+          reference: 'Customer Requirement, Version 2011-08-02, page 12'
+        req2:
+          description: 'What is required',
+          reference: 'Customer Requirement, Version 2011-08-02, page 13'
+      yaml
+    ))
+=end
+    def load( data )
+      
+      if data.is_a?(Hash)
+        #build array
+        datalist = []
+        data.each{|key,value| datalist  << value.merge(:key => key )} 
+      else
+        datalist = data
+      end
+      datalist.each{|req|
+        self << Requirement.new( req[:key], req )
+      }
+    end
+=begin rdoc
 Returns Requirement
 =end
     def [](key)
       @requirements[key]
     end
 =begin rdoc
+Loop on all requirements.
+
+Returns list of all requirements.
+=end
+    def each()
+      @requirements.each{|key,req| yield req} if block_given?
+      @requirements.values
+    end
+=begin rdoc
 Assign a testcase to an requirement.
 
 Requires:
 * Requirement key
 * testcase (Class#methodname)
 =end
-    def assign_test(req, testcase)
+    def assign_test(req, testcase, result)
       raise ArgumentError unless @requirements[req]
+      #~ raise ArgumentError, "result is no Test::Unit::TestResult but #{result.inspect}" unless result.is_a?(Test::Unit::TestResult)
       @requirements[req].test= testcase
-    end
-=begin rdoc
-Report successfull test to the requirement.
-
-This requires a previous assignment with #assign_test.
-=end
-    def test_successfull(loc)
-      #~ raise ArgumentError unless @requirements[req]
-      @requirements.each{|key,req|
-        req.successfull_test(loc) unless req[loc].nil?
-      }
+      #Assign the related result object Test::Unit::TestResult
+      @testsresults << result unless @testsresults.include?(result)
     end
 =begin rdoc
 Defines, how and if an overview of the requirements are given.
@@ -99,6 +168,28 @@ Used in #overview. More details see there.
       end
     end 
 =begin rdoc
+=end
+  def analyse_testresults()
+    @testsresults.each{|result|
+      result.faults.each{|fault|
+        self.each{|req|
+          if ! req[fault.test_name].nil?
+            @log.debug("Set result #{fault} to #{req}") if @log.info?
+            case fault
+              when Test::Unit::Failure; req.result(fault.test_name, :failure)
+              when Test::Unit::Pending; req.result(fault.test_name, :pend)
+              when Test::Unit::Omission; req.result(fault.test_name, :omit)
+              else 
+                @log.error("unknown fault-type #{fault.inspect}") if @log.error?
+                req.set_result(fault.test_name, :error)
+            end
+          end
+        }
+        
+      }
+    }
+  end
+=begin rdoc
 Give an overview.
 
 Returns a hash with test results for the requirements.
@@ -113,6 +204,8 @@ The parameter defines alternative report types:
 =end
     def overview(report_type = @report_type )
       
+      analyse_testresults()
+      
       txt = []
       hash = {}
       
@@ -120,7 +213,7 @@ The parameter defines alternative report types:
         if req.successfull?
           txt << "Requirement #{key} was successfull tested (#{req.testresults.join(', ')})"
           hash[key] = true
-        elsif req.tested?
+        elsif req.test_defined?
           txt << "Requirement #{key} was unsuccessfull tested (#{req.testresults.join(', ')})"
           hash[key] = false
         else

data/lib/test4requirements/shoulda.rb

@@ -1,77 +1,114 @@
-=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
+=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 Test4requirements
+=begin rdoc
+Dummy class TestResults for use with Shoulda
+=end
+  class TestResults
+    def initialize()
+      @faults = []
+    end
+    attr_reader :faults
+  end #class TestResults
+end #module Test4requirements
+
+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, Test4requirements::TestResults.new)
+          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, Test4requirements::TestResults.new )
+        end
+        should_old(name_or_matcher, options = {}, &blk)
+      end #should
+  end# class Context
+end #Shoulda
+
+__END__
+
+include Test4requirements
+    $reqs = RequirementList.new(:reqId, :req1,:req2,:req3)
+    class Testcase < Test::Unit::TestCase
+      #Set class name. Normally class name.
+      def self.name;'Test_ShouldaTest';end
+      
+      self.requirements=  $reqs
+      #Add requirement as parameter of should
+      should 'request_1', requirement: :req1  do
+        assert_equal(2,1+1)
+      end
+      
+      #add requirement via requirement command
+      should 'request_2' do
+        assign_requirement(:req2)  #this test is testing requirement 1
+        assert_equal(3,1+1)
+      end
+    end
+  
+    #~ suite = @testcase.suite #run tests
+    #~ Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+p $reqs.overview