testability-driver 1.1.0 → 1.1.1

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

@@ -29,6 +29,8 @@ module MobyBase
     @@behaviours = []
     @@behaviours_cache = {}
     @@modules_cache = {}
+
+    @@plugin_cache = []
     
     # behaviour xml files path
     @@path = File.join( MobyUtil::FileHelper.tdriver_home, '/behaviours/*.xml' )
@@ -126,60 +128,50 @@ module MobyBase
     # merge user-defined rules on top of default rules set
     #rules = { :sut_type => ['*'], :object_type => ['*'], :input_type => ['*'], :version => ['*'] }.merge!( rules )
 
+    raise ArgumentError, 'Target object not defined in rules hash' if rules[ :object ].nil?      
+
     rules.default = ['*']
 
-    Kernel::raise ArgumentError.new( "Target object not defined in rules hash" ) if rules[ :object ].nil?      
+    # retrieve enabled plugins from PluginService
+    enabled_plugins = TDriver::PluginService.enabled_plugins 
 
     # apply behaviours to target object
-    ( get_object_behaviours( rules ) ).each{ | behaviour_index |
+    get_object_behaviours( rules ).each{ | behaviour_index |
 
       behaviour_data = @@behaviours[ behaviour_index ]
 
-      # skip if required plugin is not registered or enabled
-      next if behaviour_data[ :requires ].collect{ | plugin | 
-
-        #MobyUtil::PluginService.instance.plugin_registered?( plugin ) && MobyUtil::PluginService.instance.plugin_enabled?( plugin )
-
-        # verify if plugin is enabled -- exception will be catched if plugin is not registered 
-        MobyUtil::PluginService.instance.plugin_enabled?( plugin ) rescue false
-
-      }.include?( false )
+      # skip if required plugin is not registered or enabled; compare requires array and enabled_plugins array
+      next unless ( behaviour_data[ :requires ] - enabled_plugins ).empty?
 
       begin
 
-        #behaviour_module = MobyUtil::KernelHelper.get_constant( behaviour_data[ :module ][ :name ] )
-
         # retrieve behaviour module from cache and extend target object
         rules[ :object ].extend( 
+
           @@modules_cache.fetch( behaviour_data[ :module ][ :name ] ){ | name |                  
+
             # ... or store to cache for the next time if not found 
             @@modules_cache[ name ] = MobyUtil::KernelHelper.get_constant( name )
+
           } 
+
         )
 
-      rescue NameError => exception
+      rescue NameError
+
+        raise NameError, "Implementation for behaviour #{ behaviour_data[ :name ] } does not exist. (#{ behaviour_data[ :module ][ :name ] })"
 
-        Kernel::raise exception.class.new( 
-                        "Implementation for behaviour %s does not exist. (%s)" % [ behaviour_data[ :name ], behaviour_data[ :module ][ :name ] ]
-                        )
 
-      rescue Exception => exception
+      rescue
 
-        Kernel::raise RuntimeError.new( 
-                       "Error while applying %s (%s) behaviour to target object. Reason: %s (%s)" % [
-                         behaviour_data[ :name ],
-                         behaviour_data[ :module ][ :name ],  
-                         exception.message,
-                         exception.class
-                       ]
-                       )
+        raise RuntimeError, "Error while applying #{ behaviour_data[ :name ] } (#{ behaviour_data[ :module ][ :name ] }) behaviour to target object. Reason: #{ $!.message } (#{ $!.class })"
 
       end
 
       # add behaviour information to test object
       rules[ :object ].instance_exec{ 
 
-        @object_behaviours.push( behaviour_index ) unless @object_behaviours.include? behaviour_index 
+        @object_behaviours.push( behaviour_index ) unless @object_behaviours.include?( behaviour_index )
 
       }
 
@@ -197,7 +189,7 @@ module MobyBase
 
     begin
 
-    Dir.glob( behaviour_files ).each { | behaviour | 
+    Dir.glob( behaviour_files ).each{ | behaviour | 
 
       @file_name = behaviour
 
@@ -341,47 +333,86 @@ module MobyBase
 
   end
 
+=begin
   def get_object_behaviours( rules )
 
-      # calculate hash for behaviour rules / hash value will be used to identify similar objects
-      behaviour_hash = Hash[ rules.select{ | key, value | key != :object  } ].hash
+    # calculate hash for behaviour rules / hash value will be used to identify similar objects
+    behaviour_hash = Hash[ rules.select{ | key, value | key != :object  } ].hash
 
-      if @@behaviours_cache.has_key?( behaviour_hash )
+    if @@behaviours_cache.has_key?( behaviour_hash )
 
-        # retrieve behaviour module indexes from cache
-        @@behaviours_cache[ behaviour_hash ]
+      # retrieve behaviour module indexes from cache
+      @@behaviours_cache[ behaviour_hash ]
 
-      else
+    else
 
-    rules.default = [ '*' ]
+      rules.default = [ '*' ]
 
-    extended_modules = []
+      extended_modules = []
 
-    @@behaviours.each_with_index{ | behaviour, index |
+      @@behaviours.each_with_index{ | behaviour, index |
 
-      if (   ( rules[ :name ] == behaviour[ :name ] ) || 
+        if ( ( rules[ :name ] == behaviour[ :name ] ) || 
 
-        ( rules[ :name ] == [ '*' ] && 
+          ( rules[ :name ] == [ '*' ] && 
 
-#         ( !( rules[ :sut_type ] & behaviour[ :sut_type ] ).empty? ) && 
-         ( !( rules[ :object_type ] & behaviour[ :object_type ] ).empty? ) &&
-         ( !( rules[ :input_type ] & behaviour[ :input_type ] ).empty? ) &&
-         ( !( rules[ :env ] & behaviour[ :env ] ).empty? ) &&
-         ( !( rules[ :version ] & behaviour[ :version ] ).empty? ) ) )
+          #         ( !( rules[ :sut_type ] & behaviour[ :sut_type ] ).empty? ) && 
+          ( !( rules[ :object_type ] & behaviour[ :object_type ] ).empty? ) &&
+          ( !( rules[ :input_type ] & behaviour[ :input_type ] ).empty? ) &&
+          ( !( rules[ :env ] & behaviour[ :env ] ).empty? ) &&
+          ( !( rules[ :version ] & behaviour[ :version ] ).empty? ) ) )
 
-      # retrieve list of extended modules
-      extended_modules << index
+          # retrieve list of extended modules
+          extended_modules << index
 
-      end
+        end
 
-    }
+      }
 
-        # store behaviour module indexes to cache
-        @@behaviours_cache[ behaviour_hash ] = extended_modules
+      # store behaviour module indexes to cache
+      @@behaviours_cache[ behaviour_hash ] = extended_modules
 
-      end
+    end
 
   end
+=end
+
+  def get_object_behaviours( rule )
+
+    # 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
+
 
   def get_behaviour_from_cache( target, sut_type, object_type, sut_version, input_type )
 

data/lib/tdriver/base/sut/controller.rb

@@ -84,30 +84,39 @@ module MobyBase
 		# TypeError:: Wrong argument type $1 for command_data (expected $2)
 		# MobyBase::CommandNotFoundError:: if no implementation is found for the CommandData object
 		def execute_command( command_data )
-
-      command_data.check_type( MobyCommand::CommandData, "Wrong argument type $1 for command_data (expected $2)" )
-
-			@execution_order.each{ | controller |
-
-				begin 
-
-					# extend command_data with combinination of command data object name and module name to be extended  
-					eval 'command_data.extend %s::%s' % [ @sut_controllers[ controller ].first.first, command_data.class.name.scan( /::(.+)/ ).first.first ]
-
-					# break if controller associated succesfully 
-					break
-
-				rescue NameError
-
-					# raise exception only if none controller found
-					Kernel::raise MobyBase::ControllerNotFoundError.new( 'No controller found for CommandData object %s' % command_data.inspect ) unless controller.object_id != @execution_order.last.object_id
-				end
-
-			}
-			
-			command_data.set_adapter( @sut_adapter )      
-			command_data.execute
-
+        command_data.check_type( MobyCommand::CommandData, "Wrong argument type $1 for command_data (expected $2)" )
+        
+        @execution_order.each{ | controller |
+          
+          begin 
+            
+            # extend command_data with combinination of command data object name and module name to be extended  
+            eval 'command_data.extend %s::%s' % [ @sut_controllers[ controller ].first.first, command_data.class.name.scan( /::(.+)/ ).first.first ]
+
+            # break if controller associated succesfully 
+            break
+
+          rescue NameError
+
+            # raise exception only if none controller found
+            Kernel::raise MobyBase::ControllerNotFoundError.new( 'No controller found for CommandData object %s' % command_data.inspect ) unless controller.object_id != @execution_order.last.object_id
+          end
+
+        }
+        
+        command_data.set_adapter( @sut_adapter )      
+      retries = 0
+      begin 
+        command_data.execute
+      rescue Errno::EPIPE, IOError => e
+         raise if retries == 1
+         retries += 1
+         if MobyBase::SUTFactory.instance.connected_suts.include?(@sut_adapter.sut_id.to_sym)
+           @sut_adapter.disconnect
+           @sut_adapter.connect(@sut_adapter.sut_id)
+         end
+        retry
+      end
 		end
 
 		# enable hooking for performance measurement & debug logging

data/lib/tdriver/base/sut/factory.rb

@@ -73,13 +73,13 @@ module MobyBase
     sut = $parameters[ sut_id, nil ]
 
     # raise exception if sut was not found
-    Kernel::raise ArgumentError.new( "%s not defined in TDriver parameters XML" % [ sut_id ]) if sut.nil?
+    raise ArgumentError, "#{ sut_id.to_s } not defined in TDriver parameters XML" if sut.nil?
     
     # retrieve sut type from parameters
     sut_type = sut[ :type, nil ]
     
     # raise exception if sut type was not found
-    Kernel::raise RuntimeError.new( "SUT parameter 'type' not defined for %s in TDriver parameters/templates XML" % [ sut_id ] ) if sut_type.nil?
+    raise RuntimeError, "SUT parameter 'type' not defined for #{ sut_id.to_s } in TDriver parameters/templates XML" if sut_type.nil?
 
     sut_type_symbol = sut_type.downcase.to_sym
 
@@ -90,7 +90,7 @@ module MobyBase
     sut_env = sut[ :env, '*' ]
 
     # verify that sut plugin is defined in sut configuration
-    Kernel::raise RuntimeError.new( "SUT parameter 'sut_plugin' not defined for %s (%s)" % [ sut_id, sut_type ] ) if sut_plugin.nil?
+    raise RuntimeError, "SUT parameter 'sut_plugin' not defined for #{ sut_id.to_s } (#{ sut_type.to_s })" if sut_plugin.nil?
     
     # flag to determine that should exception be raised; allow one retry, then set flag to true if error still occures
     raise_exception = false
@@ -98,26 +98,27 @@ module MobyBase
     begin
 
       # verify that sut plugin is registered
-      if MobyUtil::PluginService.instance.plugin_registered?( sut_plugin, :sut )
+      if TDriver::PluginService.plugin_registered?( sut_plugin, :sut )
         
         # create sut object
-        created_sut = MobyUtil::PluginService.instance.call_plugin_method( sut_plugin, :make_sut, sut_id )
+        created_sut = TDriver::PluginService.call_plugin_method( sut_plugin, :make_sut, sut_id )
 
       else
 
         # raise error if sut was not registered
-        Kernel::raise NotImplementedError.new( "No plugin implementation found for SUT type: %s" % [ sut_type ] )
+        raise NotImplementedError, "No plugin implementation found for SUT type: #{ sut_type }"
 
       end
 
       rescue Exception => exception
 
       # if sut was not registered, try to load it
-      MobyUtil::PluginService.instance.load_plugin( sut_plugin ) if exception.kind_of?( NotImplementedError )
+      TDriver::PluginService.load_plugin( sut_plugin ) if exception.kind_of?( NotImplementedError )
 
       if !raise_exception
 
         raise_exception = true
+
         retry 
         
       else
@@ -161,29 +162,31 @@ module MobyBase
 
         begin
 
-        # verify that extension plugin is registered
-        unless MobyUtil::PluginService.instance.plugin_registered?( plugin_name, :extension )
+          # verify that extension plugin is registered
+          unless TDriver::PluginService.plugin_registered?( plugin_name, :extension )
 
-          # raise error if sut was not registered
-          Kernel::raise NotImplementedError.new( "Extension plugin not found %s" % [ plugin_name ] )
+            # raise error if sut was not registered
+            raise NotImplementedError, "Extension plugin not found #{ plugin_name }"
 
-        end
+          end
 
         rescue Exception => exception
 
-        # if sut was not registered, try to load it
-        MobyUtil::PluginService.instance.load_plugin( plugin_name ) if exception.kind_of?( NotImplementedError )
+          # if sut was not registered, try to load it
+          TDriver::PluginService.load_plugin( plugin_name ) if exception.kind_of?( NotImplementedError )
 
-        if !raise_exception
+          if !raise_exception
 
-          raise_exception = true
-          retry 
-        else
+            raise_exception = true
 
-          # still errors, raise original exception
-          Kernel::raise exception
+            retry
 
-        end
+          else
+
+            # still errors, raise original exception
+            Kernel::raise exception
+
+          end
 
         end
 

data/lib/tdriver/base/sut/generic/behaviours/application.rb

@@ -99,38 +99,53 @@ module MobyBehaviour
       begin
         
         # check if closable
-        Kernel::raise RuntimeError( "The application is of a type that cannot be closed." ) unless self.closable?
+        raise RuntimeError, 'The application is of a type that cannot be closed.' unless closable?
         
+        # default options
         default_options = { :force_kill => nil, :check_process => true }
-                
+        
+        # for backwards compatibility
         if options_hash.kind_of?( Hash )
 
+          # merge user defined options with default options 
           close_options = default_options.merge( options_hash )
 
         else
 
-          # support legacy option of defining only force_kill
+          # support legacy option of defining only force_kill as argument
           close_options = default_options
 
+          # if options defined
           if options_hash != nil
 
+            # workaround/backwards compatibility: allow string as hash key value 
+            options_hash = options_hash.to_boolean if options_hash.kind_of?( String )
+
             # verify options_hash value
-            options_hash.check_type( [ Hash, FalseClass, TrueClass ], "Wrong argument type $1 for options hash (expected $2)" )
+            options_hash.check_type( [ FalseClass, TrueClass ], "Wrong argument type $1 for options hash (expected $2)" )
 
+            # store force_kill value
             close_options[ :force_kill ] = options_hash
 
           end
 
         end
+
+        # workaround/backwards compatibility: allow string as hash key value 
+        close_options[ :force_kill ] = close_options[ :force_kill ].to_boolean if close_options[ :force_kill ].kind_of?( String )
         
-        # verify :force_kill variable type
+        # verify :force_kill value type
         close_options[ :force_kill ].check_type( [ NilClass, TrueClass, FalseClass ], "Wrong argument type $1 for :force_kill (expected $2)" )
 
-        # verify :check_process variable type
+        # workaround/backwards compatibility: allow string as hash key value 
+        close_options[ :check_process ] = close_options[ :check_process ].to_boolean if close_options[ :check_process ].kind_of?( String )
+
+        # verify :check_process value type
         close_options[ :check_process ].check_type( [ TrueClass, FalseClass ], "Wrong argument type $1 for :check_process (expected $2)" )
         
-        if close_options[ :force_kill ] != nil                
+        if close_options[ :force_kill ] != nil
 
+=begin
           @sut.execute_command( 
             MobyCommand::Application.new( 
               :Close,     # command_type
@@ -139,6 +154,7 @@ module MobyBehaviour
               self.sut,   # sut
               nil,        # arguments
               nil,        # environment
+              nil,        # working directory
               nil,        # events_to_listen
               nil,        # signals_to_listen
               {           # flags 
@@ -146,41 +162,73 @@ module MobyBehaviour
               } 
             )
           )
+=end
+
+          @sut.execute_command( 
+            MobyCommand::Application.new( 
+              :Close,     # command_type
+              {
+                :application_name => self.name,
+                :application_uid => self.uid,  
+                :sut => self.sut,              
+                :flags => { :force_kill => close_options[ :force_kill ] }
+              } 
+            )
+          )
 
         else   
 
+=begin
           @sut.execute_command( 
             MobyCommand::Application.new( 
               :Close, 
               self.name, 
               self.uid, 
-              self.sut, 
-              nil 
+              self.sut
+            ) 
+          )
+=end
+
+          @sut.execute_command( 
+            MobyCommand::Application.new( 
+              :Close, 
+              { 
+                :application_name => self.name, 
+                :application_uid => self.uid, 
+                :sut => self.sut
+              }
             ) 
           )
 
         end
 
-        # Disable logging
+        # store start time
+        start_time = Time.now
+
+        # store original logger state
         original_logger_state = $logger.enabled
+
+        # disable logging
         $logger.enabled = false
 
-        # verify close results
-        # store start time
-          start_time = Time.now
-          timeout_time = $parameters[ self.sut.id ][ :application_synchronization_timeout, '60' ].to_f
-        begin
+        # retrieve application synchronization timeout value
+        timeout_time = $parameters[ self.sut.id ][ :application_synchronization_timeout, '60' ].to_f
 
-          application_identification_hash = { :type => 'application', :id => @id }
+        # create application identification hash
+        application_identification_hash = { :type => 'application', :id => @id }
 
+        begin
+
+          # verify close results
           MobyUtil::Retryable.until(
             :timeout => timeout_time,
             :interval => $parameters[ self.sut.id ][ :application_synchronization_retry_interval, '0.25' ].to_f,
             :exception => MobyBase::VerificationError,
-            :unless => [MobyBase::TestObjectNotFoundError, MobyBase::ApplicationNotAvailableError] ) {
+            :unless => [ MobyBase::TestObjectNotFoundError, MobyBase::ApplicationNotAvailableError ] 
+          ){
 
             # raises MobyBase::ApplicationNotAvailableError if application was not found 
-            @sut.refresh( application_identification_hash, [{:className=>"application", :tasId => @id }] )
+            @sut.refresh( application_identification_hash, [ {:className => 'application', :tasId => @id } ] )
 
             # retrieve application object from sut.xml_data
             matches, unused_rule = TDriver::TestObjectAdapter.get_objects( @sut.xml_data, application_identification_hash, true )
@@ -189,7 +237,7 @@ module MobyBehaviour
             if ( close_options[ :check_process ] == true ) 
 
               # the application did not close
-              raise MobyBase::VerificationError.new, "Verification of close failed. The application that was to be closed is still running." if matches.count > 0 && (Time.now - start_time) >= timeout_time
+              raise MobyBase::VerificationError, "Verification of close failed. The application that was to be closed is still running." if matches.count > 0 && (Time.now - start_time) >= timeout_time
 
             elsif ( close_options[ :check_process ] == false )
 
@@ -214,7 +262,7 @@ module MobyBehaviour
             # The application could not be found, break
             break
 
-          }
+          } # MobyUtil::Retryable.until
           
         rescue MobyBase::TestObjectNotFoundError
 
@@ -224,14 +272,10 @@ module MobyBehaviour
 
           # everything ok: application not running anymore
 
-        rescue RuntimeError => e
+        rescue RuntimeError
         
-          unless ( e.message =~ /The application with Id \d+ is no longer available/ )
-
-            # something unexpected happened during the close, let exception through
-            raise e
-
-          end
+          # something unexpected happened during the close, let exception through
+          raise unless $!.message =~ /The application with Id \d+ is no longer available/
 
         ensure
 
@@ -240,14 +284,16 @@ module MobyBehaviour
 
         end
 
-      rescue Exception => exception
+      rescue Exception
+
+        $logger.behaviour "FAIL;Failed when closing.;#{ identity };close;"
 
-        $logger.log "behaviour", "FAIL;Failed when closing.;#{ identity };close;"
-        Kernel::raise exception
+        # let exception through
+        raise
 
       end
 
-      $logger.log "behaviour", "PASS;Closed successfully.;#{ identity };close;"
+      $logger.behaviour "PASS;Closed successfully.;#{ identity };close;"
 
       #@sut.application
             
@@ -345,9 +391,20 @@ module MobyBehaviour
 	#
 	#
 	def bring_to_foreground
-	  @sut.execute_command(MobyCommand::Application.new(:BringToForeground, nil, self.uid, self.sut))
-	end
 
+	  #@sut.execute_command(MobyCommand::Application.new(:BringToForeground, nil, self.uid, self.sut))
+
+	  @sut.execute_command(
+	    MobyCommand::Application.new(
+	      :BringToForeground, 
+	      { 
+	        :application_uid => self.uid, 
+	        :sut => self.sut
+        }
+      )
+    )
+
+	end
 
 	# == description
 	# Kills the application process
@@ -359,7 +416,19 @@ module MobyBehaviour
 	#
 	def kill
 
-	  @sut.execute_command( MobyCommand::Application.new( :Kill, self.executable_name, self.uid, self.sut, nil ) )
+	  #@sut.execute_command( MobyCommand::Application.new( :Kill, self.executable_name, self.uid, self.sut ) )
+
+	  @sut.execute_command( 
+	    MobyCommand::Application.new( 
+	      :Kill, 
+	      {
+	        :application_name => self.executable_name, 
+	        :application_uid => self.uid, 
+	        :sut => self.sut 
+        }
+      ) 
+    )
+
 
 	end