testability-driver 1.0.3 → 1.0.4

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

@@ -92,7 +92,7 @@ module MobyBase
 				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 ], command_data.class.name.scan( /::(.+)/ ) ]
+					eval 'command_data.extend %s::%s' % [ @sut_controllers[ controller ].first.first, command_data.class.name.scan( /::(.+)/ ).first.first ]
 
 					# break if controller associated succesfully 
 					break
@@ -111,7 +111,7 @@ module MobyBase
 		end
 
 		# enable hooking for performance measurement & debug logging
-		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+		TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
 
 	end # SutController

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

@@ -23,224 +23,232 @@ module MobyBase
   # Hides actual SUT object from the clients -> clients should be able to use the instantiated SUT object as if it was any SUT 
   class SUTFactory
 
-	include Singleton
+  include Singleton
 
-	# Initialize the singleton
-	def initialize()
+  # Initialize the singleton
+  def initialize()
 
-	  reset
+    reset
 
-	end
+  end
 
-	# Create/reset hash to store sut ids for all current suts
-	def reset
+  # Create/reset hash to store sut ids for all current suts
+  def reset
 
-	  @_sut_list = {}
+    @_sut_list = {}
 
-	end
+  end
 
-	def mapped_sut?( sut_id )
+  def mapped_sut?( sut_id )
 
-	  MobyUtil::Parameter[ :mappings, {} ].has_key?( sut_id.to_sym )
+    $parameters[ :mappings, {} ].has_key?( sut_id.to_sym )
 
-	end
+  end
 
 
-	def get_mapped_sut( sut_id )
+  def get_mapped_sut( sut_id )
 
-	  MobyUtil::Parameter[ :mappings ][ sut_id.to_sym ].to_sym
+    $parameters[ :mappings ][ sut_id.to_sym ].to_sym
 
-	end
+  end
 
-	# Function to create the actual SUT objects based on the 'sut' attribute.
-	# === params
-	# sut_type:: sut_type - sut type, supportes all types defined by SUTFactory constants
-	# id:: id - unique identifier for identifying particular SUT from each other. Is propagated to proper initializers.
-	# === returns
-	# return:: SUT object
-	# raise:: 
-	# ArgumentError:: SUT ID '%s' not found from tdriver_parameters.xml
-	def make( sut_attributes )
+  # Function to create the actual SUT objects based on the 'sut' attribute.
+  # === params
+  # sut_type:: sut_type - sut type, supportes all types defined by SUTFactory constants
+  # id:: id - unique identifier for identifying particular SUT from each other. Is propagated to proper initializers.
+  # === returns
+  # return:: SUT object
+  # raise:: 
+  # ArgumentError:: SUT ID '%s' not found from tdriver_parameters.xml
+  def make( sut_attributes )
 
-      sut_id = retrieve_sut_id_from_hash( sut_attributes )
+    sut_id = retrieve_sut_id_from_hash( sut_attributes )
 
-	  sut_id = get_mapped_sut( sut_id ) if mapped_sut?( sut_id )
+    sut_id = get_mapped_sut( sut_id ) if mapped_sut?( sut_id )
 
-	  # if sut is already connected, return existing sut
-	  return get_sut_from_list( sut_id ) if sut_exists?( sut_id )
+    # if sut is already connected, return existing sut
+    return get_sut_from_list( sut_id ) if sut_exists?( sut_id )
 
+    # retrieve sut from parameters
+    sut = $parameters[ sut_id, nil ]
 
-	  # retrieve sut from parameters
-      sut = MobyUtil::Parameter[ 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?
+    
+    # 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 exception if sut was not found
-	  Kernel::raise ArgumentError.new( "%s not defined in TDriver parameters XML" % [ sut_id ]) 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?
+    sut_type_symbol = sut_type.downcase.to_sym
 
-	  sut_type_symbol = sut_type.downcase.to_sym
+    # retrieve plugin name that implements given sut
+    sut_plugin = sut[ :sut_plugin, nil ]
 
-	  # retrieve plugin name that implements given sut
-	  sut_plugin = sut[ :sut_plugin, nil ]
+    # retrieve enviroment value from sut, use '*' as default
+    sut_env = sut[ :env, '*' ]
 
-	  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?
+    
+    # flag to determine that should exception be raised; allow one retry, then set flag to true if error still occures
+    raise_exception = false
 
-	  # 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?
-	  
-	  # flag to determine that should exception be raised; allow one retry, then set flag to true if error still occures
-	  raise_exception = false
+    begin
 
-	  begin
+      # verify that sut plugin is registered
+      if MobyUtil::PluginService.instance.plugin_registered?( sut_plugin, :sut )
+        
+        # create sut object
+        created_sut = MobyUtil::PluginService.instance.call_plugin_method( sut_plugin, :make_sut, sut_id )
 
-		# verify that sut plugin is registered
-		if MobyUtil::PluginService.instance.plugin_registered?( sut_plugin, :sut )
-		  
-		  # create sut object
-		  created_sut = MobyUtil::PluginService.instance.call_plugin_method( sut_plugin, :make_sut, sut_id )
+      else
 
-		else
+        # raise error if sut was not registered
+        Kernel::raise NotImplementedError.new( "No plugin implementation found for SUT type: %s" % [ sut_type ] )
 
-		  # raise error if sut was not registered
-		  Kernel::raise NotImplementedError.new( "No plugin implementation found for SUT type: %s" % [ sut_type ] )
+      end
 
-		end
+      rescue Exception => exception
 
-	  rescue Exception => exception
+      # if sut was not registered, try to load it
+      MobyUtil::PluginService.instance.load_plugin( sut_plugin ) if exception.kind_of?( NotImplementedError )
 
-		# if sut was not registered, try to load it
-		MobyUtil::PluginService.instance.load_plugin( sut_plugin ) if exception.kind_of?( NotImplementedError )
+      if !raise_exception
 
-		if !raise_exception
+        raise_exception = true
+        retry 
+        
+      else
 
-		  raise_exception = true
-		  retry 
-		  
-		else
+        # still errors, raise original exception
+        Kernel::raise exception
 
-		  # still errors, raise original exception
-		  Kernel::raise exception
+      end
 
-		end
+    end
 
-	  end
+    # store SUT type to sut object
+    created_sut.instance_variable_set( :@ui_type, sut_type )
 
-	  # sut type version, default: nil    
-	  created_sut.instance_eval { 
-		@ui_type = sut_type; 
-		@ui_version = MobyUtil::Parameter[ sut_id ][ :version, nil ]; 
-		@input = MobyUtil::Parameter[ sut_id ][ :input_type, nil ]; 
-	  }
-	  
-	  # add behaviours to sut
-	  created_sut.extend( MobyBehaviour::ObjectBehaviourComposition )
+    # store SUT UI version to sut object
+    created_sut.instance_variable_set( :@ui_version, $parameters[ sut_id ][ :version, nil ] )
 
-	  # retrieve list of optional extension plugins
-	  @extension_plugins = MobyUtil::Parameter[ sut_id ][ :extension_plugins, "" ].split( ";" )
+    # store SUT input type to sut object
+    created_sut.instance_variable_set( :@input, $parameters[ sut_id ][ :input_type, nil ] )
 
-	  # load optional extension plugins
-	  if @extension_plugins.count > 0
+=begin
+    # sut type version, default: nil    
+    created_sut.instance_eval{
 
-		@extension_plugins.each{ | plugin_name |
+      @ui_type = sut_type 
+      @ui_version = $parameters[ sut_id ][ :version, nil ]
+      @input = $parameters[ sut_id ][ :input_type, nil ]
 
-		  raise_exception = false
+    }
+=end
+    
+    # retrieve list of optional extension plugins
+    @extension_plugins = $parameters[ sut_id ][ :extension_plugins, "" ].split( ";" )
 
-		  begin
+    # load optional extension plugins
+    if @extension_plugins.count > 0
 
-			# verify that extension plugin is registered
-			unless MobyUtil::PluginService.instance.plugin_registered?( plugin_name, :extension )
+      @extension_plugins.each{ | plugin_name |
 
-			  # raise error if sut was not registered
-			  Kernel::raise NotImplementedError.new( "Extension plugin not found %s" % [ plugin_name ] )
+        raise_exception = false
 
-			end
+        begin
 
-		  rescue Exception => exception
+        # verify that extension plugin is registered
+        unless MobyUtil::PluginService.instance.plugin_registered?( plugin_name, :extension )
 
-			# if sut was not registered, try to load it
-			MobyUtil::PluginService.instance.load_plugin( plugin_name ) if exception.kind_of?( NotImplementedError )
+          # raise error if sut was not registered
+          Kernel::raise NotImplementedError.new( "Extension plugin not found %s" % [ plugin_name ] )
 
-			if !raise_exception
+        end
 
-			  raise_exception = true
-			  retry 
-			else
+        rescue Exception => exception
 
-			  # still errors, raise original exception
-			  Kernel::raise exception
+        # if sut was not registered, try to load it
+        MobyUtil::PluginService.instance.load_plugin( plugin_name ) if exception.kind_of?( NotImplementedError )
 
-			end
+        if !raise_exception
 
-		  end
+          raise_exception = true
+          retry 
+        else
 
-		}
+          # still errors, raise original exception
+          Kernel::raise exception
 
-	  end
+        end
 
-	  # apply sut generic behaviours
-	  created_sut.apply_behaviour!( 
-								   :object_type => [ 'sut' ], 
-#								   :sut_type => [ '*', sut_type.upcase ], 
-#								   :sut_type => [ '*', sut_type ], 
-								   :input_type => [ '*', created_sut.input.to_s ],
-								   :env => [ '*', *sut_env.to_s.split(";") ],
-								   :version => [ '*', created_sut.ui_version.to_s ]
-								   )
+        end
 
-	  @_sut_list[ sut_id ] = { :sut => created_sut, :is_connected => true }
+      }
 
-	  created_sut
+    end
 
-	end
+    # apply sut generic behaviours
+    MobyBase::BehaviourFactory.instance.apply_behaviour!(
 
-	def disconnect_sut( sut_attributes )
+     :object => created_sut,
+     :object_type => [ 'sut' ], 
+     :sut_type => [ '*', created_sut.ui_type ],
+     :input_type => [ '*', created_sut.input.to_s ],
+     :env => [ '*', *sut_env.to_s.split(";") ],
+     :version => [ '*', created_sut.ui_version.to_s ]
 
-      sut_id = retrieve_sut_id_from_hash( sut_attributes )
+    )
+
+    @_sut_list[ sut_id ] = { :sut => created_sut, :is_connected => true }
 
-	  Kernel::raise RuntimeError.new( 
-									 
-									 "Unable disconnect SUT due to %s is not connected" % [ sut_id ] 
-									 
-									 ) unless sut_exists?( sut_id ) && @_sut_list[ sut_id ][ :is_connected ] 
-	  
-	  @_sut_list[ sut_id ][ :sut ].disconnect
-	  
-	  @_sut_list[ sut_id ][ :is_connected ] = false
+    created_sut
 
-	end 
+  end
 
-	def reboot_sut( sut_attributes )
+  def disconnect_sut( sut_attributes )
+
+    sut_id = retrieve_sut_id_from_hash( sut_attributes )
+
+    Kernel::raise RuntimeError.new( "Unable disconnect SUT due to #{ sut_id.to_s } is not connected" ) unless sut_exists?( sut_id ) && @_sut_list[ sut_id ][ :is_connected ] 
+    
+    @_sut_list[ sut_id ][ :sut ].disconnect
+    
+    @_sut_list[ sut_id ][ :is_connected ] = false
+
+  end 
+
+  def reboot_sut( sut_attributes )
 
       sut_id = retrieve_sut_id_from_hash( sut_attributes )
 
-	  Kernel::raise RuntimeError.new( 
-									 
-									 "Unable to reboot SUT due to %s is not connected" % [ sut_id ] 
-									 
-									 ) unless sut_exists?( sut_id ) && @_sut_list[ sut_id ][ :is_connected ]
-	  
-	  @_sut_list[ sut_id ][ :sut ].reboot
+    Kernel::raise RuntimeError.new( 
+                   
+                   "Unable to reboot SUT due to %s is not connected" % [ sut_id ] 
+                   
+                   ) unless sut_exists?( sut_id ) && @_sut_list[ sut_id ][ :is_connected ]
+    
+    @_sut_list[ sut_id ][ :sut ].reboot
 
-	  disconnect_sut( sut_id )
+    disconnect_sut( sut_id )
 
-	end
+  end
 
-	def connected_suts
+  def connected_suts
 
-	  @_sut_list
+    @_sut_list
 
-	end
+  end
 
-	private
+  private
 
     def retrieve_sut_id_from_hash( sut_attributes )
 
-	  # usability improvement: threat sut_attribute as SUT id if it is type of Symbol or String
-	  sut_attributes = { :id => sut_attributes.to_sym } if [ String, Symbol ].include?( sut_attributes.class )
+    # usability improvement: threat sut_attribute as SUT id if it is type of Symbol or String
+    sut_attributes = { :id => sut_attributes.to_sym } if [ String, Symbol ].include?( sut_attributes.class )
 
       # verify that sut_attributes is type of Hash
       sut_attributes.check_type( [ Hash, Symbol, String ], "Wrong argument type $1 for 'sut_attributes' (expected $2)" )
@@ -254,68 +262,68 @@ module MobyBase
 
     end
 
-	# gets sut from sut-factorys list - if not connected tries to reconnect first
-	def get_sut_from_list( id )
+  # gets sut from sut-factorys list - if not connected tries to reconnect first
+  def get_sut_from_list( id )
 
-	  if !@_sut_list[ id ][ :is_connected ]
+    if !@_sut_list[ id ][ :is_connected ]
 
-		@_sut_list[ id ][ :sut ].connect( id )
-		@_sut_list[ id ][ :is_connected ] = true
+    @_sut_list[ id ][ :sut ].connect( id )
+    @_sut_list[ id ][ :is_connected ] = true
 
-	  end
+    end
 
-	  @_sut_list[ id ][ :sut ]
-	end
+    @_sut_list[ id ][ :sut ]
+  end
 
-	def sut_exists?( sut_id )
+  def sut_exists?( sut_id )
 
-	  @_sut_list.has_key?( sut_id )
+    @_sut_list.has_key?( sut_id )
 
-	end
+  end
 
-	# Finds the sut definition matching the id, either directly or via a mapping
-	#
-	# === params
-	# sut_id:: Symbol defining the id of the sut to search for
-	# === returns
-	# Symbol:: Either id if it was found in the parameter file or the id of a sut mapped to this id, or nil if no direct or mapped match was found
-	# === raises
-	# ArgumentError:: The id argument was not a Symbol
-	def find_sut_or_mapping( sut_id )
+  # Finds the sut definition matching the id, either directly or via a mapping
+  #
+  # === params
+  # sut_id:: Symbol defining the id of the sut to search for
+  # === returns
+  # Symbol:: Either id if it was found in the parameter file or the id of a sut mapped to this id, or nil if no direct or mapped match was found
+  # === raises
+  # ArgumentError:: The id argument was not a Symbol
+  def find_sut_or_mapping( sut_id )
 
       sut_id.check_type( Symbol, "Wrong argument type $1 for SUT id (expected $2)" )
       
-	  #Kernel::raise ArgumentError.new( "The id argument was not a Symbol." ) unless sut_id.kind_of?( Symbol )
+    #Kernel::raise ArgumentError.new( "The id argument was not a Symbol." ) unless sut_id.kind_of?( Symbol )
 
-	  begin
+    begin
 
-		# check if direct match exists
-		return sut_id if MobyUtil::Parameter[ sut_id ]
+    # check if direct match exists
+    return sut_id if $parameters[ sut_id ]
 
-	  rescue MobyUtil::ParameterNotFoundError
+    rescue MobyUtil::ParameterNotFoundError
 
-		# check if a mapping is defined for the id
-		begin        
+    # check if a mapping is defined for the id
+    begin        
 
-		  # return nil if no mapping exists
-		  return nil if ( mapped_id = MobyUtil::Parameter[ :mappings ][ sut_id ] ).nil?                
+      # return nil if no mapping exists
+      return nil if ( mapped_id = $parameters[ :mappings ][ sut_id ] ).nil?                
 
-		  # check if the mapped to sut id exists
-		  return mapped_id if MobyUtil::Parameter[ ( mapped_id = mapped_id.to_sym ) ]
+      # check if the mapped to sut id exists
+      return mapped_id if $parameters[ ( mapped_id = mapped_id.to_sym ) ]
 
-		rescue MobyUtil::ParameterNotFoundError
+    rescue MobyUtil::ParameterNotFoundError
 
-		  # no mappings defined in tdriver_parameters.xml or the mapped to sut was not found
-		  return nil
+      # no mappings defined in tdriver_parameters.xml or the mapped to sut was not found
+      return nil
 
-		end # check if mapping exists
+    end # check if mapping exists
 
-	  end # check if direct match exists
+    end # check if direct match exists
 
-	end
+  end
 
-	# enable hooking for performance measurement & debug logging
-	MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+  # enable hooking for performance measurement & debug logging
+  TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
   end # SUTFactory