testability-driver 1.1.1 → 1.2.1

data/lib/tdriver/base/behaviour/factory_new.rb

@@ -0,0 +1,409 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of Testability Driver. 
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+
+#require 'lib/tdriver'
+
+module TDriver
+
+  class Behaviour
+
+    def initialize( values )
+
+      # add each hash pair as class instance attribute    
+      values.each_pair do | key, value |
+
+        # cast to string; might need additional verification for invalid characters
+        key = key.to_s
+
+        # add attribute reader for hash key 
+        eval <<-CODE 
+        
+          # add attribute reader     
+          class << self; attr_reader :#{ key }; end
+
+          # set value
+          @#{ key } = #{ value.inspect };
+          
+        CODE
+      
+      end
+    
+    end
+
+    def method_missing( name, *args )
+    
+      nil
+    
+    end
+    
+    def applies_to?( rule )
+
+      rule.default = [ '*' ]
+      
+      case rule[ :name ]
+      
+        when @name
+        
+          true
+        
+        when ['*'] 
+          
+          !( rule[ :object_type ] & @object_type ).empty? && 
+          !( rule[ :input_type ] & @input_type ).empty? &&
+          !( rule[ :env ] & @env ).empty? && 
+          !( rule[ :version ] & @version ).empty? 
+
+        else
+        
+          false
+
+      end      
+
+=begin
+      # calculate hash for behaviour rule / hash value will be used to identify similar objects
+      @@behaviours_cache.fetch( rule.delete_keys( :object ).hash ){ | behaviour_hash |
+
+        rule.default = [ '*' ]
+
+        @@behaviours_cache[ behaviour_hash ] = @@behaviours.each_with_index.collect{ | behaviour, index |
+
+          case rule[ :name ]
+
+            when behaviour[ :name ]
+
+              index
+
+            when [ '*' ]
+
+              index if ( 
+                !( rule[ :object_type ] & behaviour[ :object_type ] ).empty? && 
+                !( rule[ :input_type ] & behaviour[ :input_type ] ).empty? &&
+                !( rule[ :env ] & behaviour[ :env ] ).empty? && 
+                !( rule[ :version ] & behaviour[ :version ] ).empty? 
+              )
+
+          else
+
+            nil
+
+          end
+
+        }.compact
+
+      }
+=end
+
+    end
+  
+  end
+
+  class BehaviourFactory
+  
+    class << self
+
+    public
+
+      # initialize behaviours factory
+      def init( options )
+
+        load_behaviours( 
+        
+          options[ :path ] 
+          
+        )
+
+      end
+      
+      # reset class configuration
+      def reset
+
+        # reset default values
+        initialize_class      
+      
+      end
+
+      def collect_behaviours( rule )
+
+        cache_key = rule.reject{ | key, value | key == :object }
+
+        if @behaviours_cache.has_key?( cache_key )
+        
+          @behaviours_cache[ cache_key ]
+        
+        else
+        
+          # retrieve enabled plugins from PluginService
+          enabled_plugins = TDriver::PluginService.enabled_plugins 
+
+          @behaviours_cache[ cache_key ] = @behaviours.select do | behaviour |
+
+            # skip if required plugin is not registered or enabled; compare requires array and enabled_plugins array
+            next unless ( behaviour[ 'requires' ] - enabled_plugins ).empty?
+
+            rule.default = [ '*' ]
+            
+            case rule[ :name ]
+            
+              when @name
+              
+                # exact match with name
+                true
+              
+              when ['*'] 
+   
+                # compare rules and behaviour attributes             
+                !( rule[ :object_type ] & behaviour[ 'object_type' ] ).empty? && 
+                !( rule[ :input_type ] & behaviour[ 'input_type' ] ).empty? &&
+                !( rule[ :env ] & behaviour[ 'env' ] ).empty? && 
+                !( rule[ :version ] & behaviour[ 'version' ] ).empty? 
+
+              else
+              
+                false
+
+            end
+
+          end
+
+        end
+      
+      end
+
+      def apply_behaviour( rule )
+        
+        collected_indexes = [] 
+        
+        rule[ :object ].instance_variable_get( :@object_behaviours )
+        
+        collect_behaviours( rule ).each do | behaviour |
+
+          begin
+        
+            # retrieve behaviour module
+            behaviour[ 'module' ] = MobyUtil::KernelHelper.get_constant( behaviour[ 'module' ].to_s ) unless behaviour[ 'module' ].kind_of?( Module )
+
+            # extend target object with behaviour module
+            rule[ :object ].extend( behaviour[ 'module' ] )
+
+            # store behaviour indexes
+            collected_indexes << behaviour[ 'index' ]
+
+          rescue NameError
+
+            raise NameError, "Implementation for #{ behaviour[ 'name' ] } behaviour does not exist. (#{ behaviour[ 'module' ] })"
+          
+          rescue
+          
+            raise RuntimeError, "Error while applying #{ behaviour[ 'name' ] } (#{ behaviour[ 'module' ] }) behaviour to target object due to #{ $!.message } (#{ $!.class })"
+          
+          end
+
+        
+        end
+        
+        rule[ :object ].instance_variable_get( :@object_behaviours ).tap{ | indexes | indexes = indexes | collected_indexes }
+                  
+=begin     
+        # retrieve enabled plugins from PluginService
+        enabled_plugins = TDriver::PluginService.enabled_plugins 
+
+        @behaviours.each_with_index{ | behaviour, index |
+        
+          # skip if required plugin is not registered or enabled; compare requires array and enabled_plugins array
+          next unless ( behaviour.requires - enabled_plugins ).empty?
+        
+          if behaviour.applies_to?( rule )
+            
+            begin
+                                     
+             behaviour_module = behaviour.module
+                                     
+              # retrieve behaviour module
+              if behaviour_module.kind_of?( String )
+                behaviour_module = behaviour.instance_variable_set(:@module, MobyUtil::KernelHelper.get_constant( behaviour.module )) 
+              end
+
+              # extend target object with behaviour module
+              rule[ :object ].extend( behaviour_module )
+          
+            rescue NameError
+
+              raise NameError, "Implementation for #{ behaviour.name } behaviour does not exist. (#{ behaviour.module })"
+            
+            rescue
+            
+              raise RuntimeError, "Error while applying #{ behaviour.name } (#{ behaviour.module }) behaviour to target object due to #{ $!.message } (#{ $!.class })"
+            
+            end
+
+# new
+#MobyBase::BehaviourFactory::apply_behaviour!                                          631      2.25980600      2.21837500    3.178%      0.00358131
+
+# old
+#MobyBase::BehaviourFactory::apply_behaviour!                                          631      2.27668800      2.23749700    3.178%      0.00360806
+#MobyBase::BehaviourFactory::apply_behaviour!                                          631      0.87363100      0.77245300    1.131%      0.00138452
+#MobyBase::BehaviourFactory::apply_behaviour!                                          631      0.51659900      0.48817000    0.720%      0.00081870
+#MobyBase::BehaviourFactory::apply_behaviour!                                          631      0.73310700      0.70426600    1.030%      0.00116182
+#MobyBase::BehaviourFactory::apply_behaviour!                                          631      0.58667000      0.55826300    0.824%      0.00092975
+
+#=begin           
+            # add behaviour information to test object
+            rule[ :object ].instance_variable_get( :@object_behaviours ).tap{ | indexes |
+            
+              indexes.push( index ) unless indexes.include?( index )
+            
+            }
+#=end
+      
+            # add behaviour information to test object
+            indexes = rule[ :object ].instance_variable_get( :@object_behaviours )
+
+            indexes.push( index ) unless indexes.include?( index )
+              
+          end # if applies.to?
+          
+        }
+=end
+      
+      end
+
+    private
+      
+      # private methods and variables
+      def initialize_class
+
+        # behaviours container
+        @behaviours = []
+        
+        @behaviours_cache = {}
+            
+      end
+
+      # load and parse behaviours files
+      def load_behaviours( path )
+
+        # behaviour xml files path
+        Dir.glob( File.join( path, '*.xml' ) ){ | filename |
+ 
+          begin
+      
+            # read file contents
+            content = MobyUtil::FileHelper.get_file( filename )  
+          
+            # skip when empty file
+            next if content.empty?
+  
+            # parse behaviour xml and process each behaviours element
+            MobyUtil::XML.parse_string( content ).root.xpath( '/behaviours' ).each do | behaviours |
+
+              # retrieve root attributes
+              root_attributes = behaviours.attributes
+
+              # process each behaviour element
+              behaviours.xpath( 'behaviour' ).each do | behaviour |
+
+                # retrieve behaviour attributes - set default values if not found from element
+                attributes = behaviour.attributes.default_values(
+                  "name"        => '', 
+                  "object_type" => '', 
+                  "input_type"  => '', 
+                  "sut_type"    => '', 
+                  "version"     => '',
+                  "env"         => '*'
+                )
+
+                # verify that behaviour attributes are not empty
+                attributes.each_pair do | key, value |                  
+
+                  value.not_empty "behaviour element attribute #{ key.inspect } is not defined or empty", RuntimeError
+
+                end 
+
+                # retrieve implementation/module name
+                module_name = behaviour.at_xpath( 'module/@name' ).to_s
+
+                # verify that module name is defined
+                module_name.not_empty "behaviour #{ attributes[ "name" ].inspect } does not have module name defined or is empty", RuntimeError
+                
+                # store behaviour 
+                #@behaviours << Behaviour.new( 
+
+                # store behaviour 
+                @behaviours << { #Behaviour.new( 
+
+                  "index"       => @behaviours.count,
+    
+                  "name"        => attributes[ 'name'        ],
+                  "object_type" => attributes[ 'object_type' ].split(';'),
+                  "input_type"  => attributes[ 'input_type'  ].split(';'),
+                  "version"     => attributes[ 'version'     ].split(';'),
+                  "env"         => attributes[ 'env'         ].split(';'),
+
+                  "requires"    => root_attributes[ 'plugin' ].to_s.split(';'),
+
+                  "module"      => module_name,
+                  "file"        => behaviour.at_xpath( 'module/text()' ).to_s, # optional 
+                  
+                  "methods"     => Hash[ 
+                    # collect method details from behaviour 
+                    behaviour.xpath( 'methods/method' ).collect{ | method |                
+                      [ 
+                        method.attribute('name'),
+                        {
+                          "description" => method.at_xpath( 'description/text()' ).to_s,
+                          "example" => method.at_xpath( 'example/text()' ).to_s
+                        }
+                      ]                  
+                    }
+                  ]
+                
+                }
+                
+                # )
+
+              end # behaviour.each
+
+            end # behaviours.each
+
+          rescue MobyUtil::FileNotFoundError
+
+            raise
+
+          rescue MobyUtil::XML::ParseError
+          
+            raise MobyUtil::XML::ParseError, "Error while parsing behaviours file #{ behaviours[ :filename ] } due to #{ $!.message }"
+
+          rescue
+
+            raise RuntimeError, "Error while processing behaviours file #{ filename } due to #{ $!.message }"
+
+          end
+        
+        } # Dir.glob
+      
+      end # behaviours
+      
+    end # self
+   
+    # initialize behaviour factory
+    initialize_class
+
+  end
+  
+end

data/lib/tdriver/base/errors.rb

@@ -93,9 +93,9 @@ module MobyBase
 	# This error should be raised when verification results were not as expected
 	class VerificationError < MobyStandardError; end;
 
-	# This verification error should overwrite standard verification procedure and
-	# fail immediately
-	class ContinuousVerificationError < VerificationError; end;
+	# This verification error should overwrite standard verification procedure and fail immediately
+	#class ContinuousVerificationError < VerificationError; end;
+	class ContinuousVerificationError < MobyStandardError; end;
 
 	# This error should be raised to indicate that a synchronization timeout has elapsed without 
 	# synchronization conditions having been met.

data/lib/tdriver/base/state_object.rb

@@ -38,41 +38,100 @@ module MobyBase
     attr_accessor :parent
 
     # TODO: document me
-    attr_reader :type, :name, :id
+    attr_reader(
+        :type,      # object type
+        :name,      # object name
+        :id         # object id
+    )
 
-    # Creates a new StateObject from XML source data.
-    #
+    # Creation of a new StateObject from source data.
     # === params
-    # xml_source:: MobyUtil::XML::Element or String. Contains the root element of this state.
-    # parent:: TestObject, SUT or StateObject. Parent of this state object. Must be of type TestObjectComposition. 
+    # options:: Hash containing source data describing the object and all other required configuration values e.g. test object factory, -adapter etc.
     # === returns
-    # StateObject:: New StateObject
-    def initialize( xml_source, parent = nil )
+    # StateObject:: new StateObject instance
+    # === raises
+    def initialize( *options )
 
-      xml_element = nil
+      # clone original options array; array is modified below
+      options = options.clone
+
+      # determine is method called with new or deprecated API
+      
+      if options.count == 1 and options.first.kind_of?( Hash )
 
-      if xml_source.kind_of?( MobyUtil::XML::Element )
+        # retrieve first array element
+        options = options.shift
 
-        xml_element = xml_source
+        # verify options argument type
+        options.check_type Hash, 'wrong argument type $1 for StateObject options (expected $2)'
 
-      elsif xml_source.kind_of?( String )
+        # verify that :source_data key exists in hash       
+        source_data = options.require_key :source_data
 
-        xml_element = MobyUtil::XML.parse_string(xml_source).root
+        # retrieve reference to parent object
+        parent = options[ :parent ]
 
+        # retrieve reference to test object adapter
+        test_object_adapter = options[ :test_object_adapter ]
+      
       else
+      
+        # print warning if deprecated API is used
+        warn_caller '$1:$2 warning: deprecated API; use hash with :source_data, :parent, :test_object_adapter as argument instead of StateObject.new( source_data, parent, test_object_adapter )'
+
+        # retrieve source data
+        source_data = options.shift
 
-        Kernel::raise ArgumentError, "The XML source must be a String or MobyUtil::XML::Element, it was of type '#{ xml_source.class.to_s }'"
+        # retrieve reference to parent object
+        parent = options.shift
+
+        # retrieve reference to test object adapter
+        test_object_adapter = options.shift
 
       end
 
-      @parent = parent 
+      # verify that parent argument type is correct
+      parent.check_type [ NilClass, MobyBase::StateObject, MobyBase::TestObject, MobyBase::SUT ], 'wrong argument type $1 for parent object (expected $2)'
+
+      # verify that test object adapter argument type is correct
+      test_object_adapter.check_type [ NilClass, Class ], 'wrong argument type $1 for test object adapter (expected $2)'
+
+      # verify that source data argument type is correct
+      source_data.check_type [ String, MobyUtil::XML::Element ], 'wrong argument type $1 for source data (expected $2)'
+
+      # parse source data if given argument is type of string
+      source_data = MobyUtil::XML.parse_string( source_data ).root if source_data.kind_of?( String )
+
+      # store reference to parent object
+      @parent = parent
+
+      # store reference to test object adapter
+      if test_object_adapter.nil?
+
+        if @parent.kind_of?( MobyBase::SUT )
 
-      method(:xml_data=).call( xml_element )
+          @test_object_adapter = @parent.instance_variable_get( :@test_object_adapter )
 
+        else
+
+          @test_object_adapter = TDriver::TestObjectAdapter
+
+        end
+
+      else
+
+        @test_object_adapter = test_object_adapter
+
+      end
+
+      # retrieve object attributes
+      method( :xml_data= ).call( source_data )
+
+      # initialize child objects cache for state object
       @child_object_cache = TDriver::TestObjectCache.new
 
-      # Create accessor methods for any child state objects.
-      TDriver::TestObjectAdapter.create_child_accessors!( xml_element, self )
+      # create accessor methods for any child state objects.
+      @test_object_adapter.create_child_accessors!( source_data, self )
 
     end
 
@@ -164,7 +223,7 @@ module MobyBase
      
       @_xml_data = xml_object
             
-      unused_xpath, @name, @type, @id = TDriver::TestObjectAdapter.get_test_object_identifiers( xml_object )
+      unused_xpath, @name, @type, @id = @test_object_adapter.get_test_object_identifiers( xml_object )
       
     end
     
@@ -195,7 +254,7 @@ module MobyBase
       begin
 
         # retrieve attribute(s) from test object; never access ui state xml data directly from behaviour implementation
-        TDriver::TestObjectAdapter.test_object_attribute( @_xml_data, name.to_s )
+        @test_object_adapter.test_object_attribute( @_xml_data, name.to_s )
 
       rescue MobyBase::AttributeNotFoundError
       
@@ -261,7 +320,7 @@ module MobyBase
       dynamic_attributes = rules.strip_dynamic_attributes!
 
       # retrieve application object from sut.xml_data
-      matches, unused_rule = TDriver::TestObjectAdapter.get_objects( @_xml_data, rules, true )
+      matches, unused_rule = @test_object_adapter.get_objects( @_xml_data, rules, true )
 
       if matches.count == 0
 
@@ -280,8 +339,12 @@ module MobyBase
       
       # create state objects
       matches = matches.collect{ | object_xml |
-      
-        result = StateObject.new( object_xml, self )
+
+        result = StateObject.new( 
+          :source_data => object_xml, 
+          :parent => self,
+          :test_object_adapter => @test_object_adapter
+        )
         
         # use cached state object if once already retrieved
         get_cached_test_object!( result ).tap{ | found_in_cache |