testability-driver 0.9.2

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

@@ -0,0 +1,28 @@
+############################################################################
+## 
+## 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. 
+## 
+############################################################################
+
+
+module MobyController
+
+	# Abstract class SutAdapter. Not supposed to be instantiated as is
+	class SutAdapter
+	  
+	end # SutAdapter
+
+end # MobyController

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

@@ -0,0 +1,119 @@
+############################################################################
+## 
+## 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. 
+## 
+############################################################################
+
+
+module MobyBase
+
+	class SutController
+
+		attr_accessor :sut_controllers, :execution_order
+
+		# Creating new SutController associates SutAdapter to the controller
+		# == params
+		# sut_adapter:: MobyController::SutAdapter descendant, e.g. MobyController::QT::SutAdapter
+		# == raises
+		# NameError:: No SUT controller found for %s (%s)
+		def initialize( sut_controllers, sut_adapter )
+
+			Kernel::raise ArgumentError.new( "SUT Controller(s) must be given in String format, got #{ sut_controllers.class }" ) unless sut_controllers.kind_of? String
+
+			@sut_adapter = sut_adapter
+
+			# empty sut controllers hash
+			@sut_controllers = {}
+
+			# empty sut controller execution order, this will be used when multiple sut controllers given
+			@execution_order = []
+
+			sut_controllers.split(";").each{ | sut_controller |
+
+				begin
+
+					# controller module to extend
+					controller_module = eval( ( module_name = "MobyController::#{ sut_controller }::SutController" ) )
+
+					# add sut_controller to execution order list
+					@execution_order << sut_controller
+
+					# store controller module to cache
+					@sut_controllers[ sut_controller ] = module_name.scan( /(.+)::/ )
+
+					# extend required controller behaviour
+					self.extend controller_module
+
+				rescue NameError
+
+					Kernel::raise MobyBase::ControllerNotFoundError.new( 'No SUT controller found for %s (%s)' % [ sut_controller, module_name ] )
+
+				end
+
+			}
+
+		end
+
+		# Function to execute a command on a SutController
+		# This method is not meant to be overwritten in descendants.
+		#
+		# Associates MobyCommand::CommandData implementation based on the MobyCommand class name,
+		# by finding implementation from the same module as the SutController instance. 
+		#
+		# example: MobyController::QT::SutController instance associates MobyController::QT::Application (module)
+		# implementation to MobyCommand::Application command_data object
+		#
+		# == params
+		# command_data:: MobyCommand::CommandData descendant
+		# == returns
+		# command_data implementation specific return value
+		# == raises
+		# ArgumentError:: if command_data is not kind of MobyController::CommandData
+		# MobyBase::CommandNotFoundError:: if no implementation is found for the CommandData object
+		def execute_command( command_data )
+
+			Kernel::raise ArgumentError.new( 'Data not of type MobyController::CommandData' ) unless command_data.kind_of?( MobyCommand::CommandData )
+
+			@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 ], command_data.class.name.scan( /::(.+)/ ) ]
+
+					# 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
+
+		end
+
+		# enable hooking for performance measurement & debug logging
+		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+
+	end # SutController
+
+end # MobyBase

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

@@ -0,0 +1,287 @@
+############################################################################
+## 
+## 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. 
+## 
+############################################################################
+
+
+module MobyBase
+
+	# Class to create SUT objects
+	# 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
+
+		# Initialize the singleton
+		def initialize()
+
+			reset
+
+		end
+
+		# Create/reset hash to store sut ids for all current suts
+		def reset
+
+			@_sut_list = {}
+
+		end
+
+		def mapped_sut?( sut_id )
+
+			MobyUtil::Parameter[ :mappings, {} ].has_key?( sut_id.to_sym )
+		end
+
+
+		def get_mapped_sut( sut_id )
+
+			MobyUtil::Parameter[ :mappings ][ sut_id.to_sym ].to_sym
+
+		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_id )
+
+			# cast into symbol just in case string was passed
+			sut_id = sut_id.to_sym
+
+			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 )
+
+			#mapped_id = MobyUtil::Parameter[ sut_id, nil ].to_sym
+
+			# check if the sut or an alias exists in tdriver_parameters.xml
+			#mapped_id = find_sut_or_mapping( sut_id )
+
+			# if sut is already connected, return existing sut
+			#return get_sut_from_list( mapped_id ) if (mapped_id != sut_id and sut_exists?( mapped_id ))
+
+			Kernel::raise ArgumentError.new( "The SUT '#{ sut_id }' was not defined in TDriver parameters XML" ) if MobyUtil::Parameter[ sut_id, nil ].nil?
+
+			# retrieve sut type from parameters, raise exception if sut type was not found
+			Kernel::raise RuntimeError.new( "SUT type not defined for #{ sut_id } in TDriver parameters/templates XML" ) if ( sut_type = MobyUtil::Parameter[ sut_id ][ :type, nil ] ).nil?
+
+			sut_type_symbol = sut_type.downcase.to_sym
+
+			# retrieve plugin name that implements given sut
+			sut_plugin = MobyUtil::Parameter[ sut_id ][ :sut_plugin, nil ]
+
+			# verify that sut plugin is defined in sut configuration
+			Kernel::raise RuntimeError.new( "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
+
+				# 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
+
+					# raise error if sut was not registered
+					Kernel::raise NotImplementedError.new( "No plugin/implementation for SUT type: %s" % [ 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 )
+
+				if !raise_exception
+
+					raise_exception = true
+					retry 
+				else
+
+					# still errors, raise original exception
+					Kernel::raise exception
+
+				end
+
+			end
+
+			# 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 )
+
+			# retrieve list of optional extension plugins
+			@extension_plugins = MobyUtil::Parameter[ sut_id ][ :extension_plugins, "" ].split( ";" )
+
+			# load optional extension plugins
+			if @extension_plugins.count > 0
+
+				@extension_plugins.each{ | plugin_name |
+
+					raise_exception = false
+
+					begin
+
+						# verify that extension plugin is registered
+						unless MobyUtil::PluginService.instance.plugin_registered?( plugin_name, :extension )
+
+							# raise error if sut was not registered
+							Kernel::raise NotImplementedError.new( "Extension plugin not found %s" % [ plugin_name ] )
+
+						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 !raise_exception
+
+							raise_exception = true
+							retry 
+						else
+
+							# still errors, raise original exception
+							Kernel::raise exception
+
+						end
+
+					end
+
+				}
+
+			end
+
+			# apply sut generic behaviours
+			created_sut.apply_behaviour!( 
+				:object_type => [ 'sut' ], 
+				:sut_type => [ '*', sut_type.upcase ], 
+				:input_type => [ '*', created_sut.input.to_s ],
+				:version => [ '*', created_sut.ui_version.to_s ]
+			)
+
+			@_sut_list[ sut_id ] = { :sut => created_sut, :is_connected => true }
+
+			created_sut
+
+		end
+
+		def disconnect_sut( id )
+
+			#cast into symbol just in case string was passed
+			id = id.to_sym
+			Kernel::raise RuntimeError.new( "Not connected to device: #{ id  }" ) unless sut_exists?( id ) && @_sut_list[ id ][ :is_connected ] 
+
+			@_sut_list[ id ][ :sut ].disconnect
+			@_sut_list[ id ][ :is_connected ] = false
+
+		end 
+
+		def reboot_sut( id )
+
+			id = id.to_sym
+			Kernel::raise RuntimeError.new( "Not connected to device: #{ id }" ) unless sut_exists?( id ) && @_sut_list[ id ][ :is_connected ]
+			
+			@_sut_list[ id ][ :sut ].reboot
+			disconnect_sut( id )
+		end
+
+		def connected_suts
+
+			@_sut_list
+
+		end
+
+	private
+
+		# 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 ]
+
+				@_sut_list[ id ][ :sut ].connect( id )
+				@_sut_list[ id ][ :is_connected ] = true
+
+			end
+
+			@_sut_list[ id ][ :sut ]
+		end
+
+		def sut_exists?( sut_id )
+
+			@_sut_list.has_key?( sut_id )
+
+		end
+
+		# Finds the sut definition matching the id, either directly or via a mapping
+		#
+		# === params
+		# 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( id )
+
+			Kernel::raise ArgumentError.new( "The id argument was not a Symbol." ) unless id.kind_of?( Symbol )
+
+			begin
+
+				# check if direct match exists
+				return id if MobyUtil::Parameter[ id ]
+
+			rescue MobyUtil::ParameterNotFoundError
+
+				# check if a mapping is defined for the id
+				begin        
+
+					# return nil if no mapping exists
+					return nil if ( mapped_id = MobyUtil::Parameter[ :mappings ][ id ] ).nil?                
+
+					# check if the mapped to sut id exists
+					return mapped_id if MobyUtil::Parameter[ ( mapped_id = mapped_id.to_sym ) ]
+
+				rescue MobyUtil::ParameterNotFoundError
+
+					# 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 direct match exists
+
+		end
+
+		# enable hooking for performance measurement & debug logging
+		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+	end # SUTFactory
+
+end # MobyBase

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

@@ -0,0 +1,243 @@
+############################################################################
+## 
+## 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. 
+## 
+############################################################################
+
+module MobyBehaviour
+
+  # == description
+  # Describes the behaviour of application and its associated methods
+  #
+  # == behaviour
+  # GenericApplication
+  #
+  # == requires
+  # *
+  #
+  # == input_type
+  # *
+  #
+  # == sut_type
+  # *
+  #
+  # == sut_version
+  # *
+  #
+  # == objects
+  # application
+  #
+	module Application
+
+		include MobyBehaviour::Behaviour
+
+		# == description
+		# Closes the application whether or not it is on foreground. Note: this will currently always try to close applications, also
+		# privilegied applications
+		#
+		# == params
+		#options_hash:: Hash, possible keys :force_kill (default nil) and :check_proces (default true). 
+		#For backwards compatibility: instead of a Hash, the value can also be true, false or nil, in which case it is taken as the value of :force_kill
+		#:force_kill:: If key is set to true, the application process is killed if close fails.  If set to nil, value of key will be  taken  as defined 
+		#by 'application_close_kill' parameter in the TDriver parameter file.
+		#:check_process:: If key is set to true, success of the close method is verified by checking if the process is still active. If set to false, 
+		#TDriver will only check that the application is no longer in the foreground.	  
+		#
+		# === raises
+		# TestObjectNotFoundError:: If this application is not the foreground application on the device under test.
+		# VerificationError:: If no application test object is found after close or if this application is still in the foreground after the close.
+		# ArgumentError:: Options_hash was not a Hash or one of the keys had an invalid type.
+		# === example
+		#  @sut.application.close #closes anonymous foreground application
+		#
+		#  @mce_app = @sut.run(:name => 'Mce.exe') # launches mce app
+		#  @mce_app.close # closes above launched mce-application and verifies that correct application was closed
+		def close( options_hash = {} )
+
+			begin
+				
+				# check if closable
+				Kernel::raise RuntimeError( "The application is of a type that cannot be closed." ) unless self.closable?
+				
+				default_options = { :force_kill => nil, :check_process => true }
+								
+				if options_hash.kind_of? Hash
+				  close_options = default_options.merge options_hash
+				else
+				  # support legacy option of defining only force_kill
+				  close_options = default_options
+				  if options_hash!=nil
+                    #check that old force_kill_close argument is equal to true or false
+                    Kernel::raise ArgumentError.new( "Incorrect value for argument options_hash, expected a Hash or a bool 'true' or 'false'"  ) unless options_hash==true or options_hash==false
+				    close_options[ :force_kill ] = options_hash
+				  end				  
+				end
+				
+				raise ArgumentError.new "The options_hash :force_kill key must be true or false if it is defined, the used value was \"#{close_options[ :force_kill ]}\"." unless [nil, true, false].include? close_options[ :force_kill ]
+				raise ArgumentError.new "The options_hash :check_process key must be true or false if it is defined, the used value was \"#{close_options[ :check_process ]}\"." unless [true, false].include? close_options[ :check_process ]
+				
+                if close_options[ :force_kill ] != nil                
+                  flags_hash = { }
+                  flags_hash[ :force_kill ] = close_options[ :force_kill ]
+                  #execute_command( command_type = nil, app_name = nil, app_uid = nil, sut = nil, arguments = nil, environment = nil, events_to_listen = nil, signals_to_listen = nil, flags = nil)
+                  @sut.execute_command( MobyCommand::Application.new( :Close, self.name, self.uid, self.sut, nil, nil, nil, nil, flags_hash) )
+                else   
+                  @sut.execute_command( MobyCommand::Application.new( :Close, self.name, self.uid, self.sut, nil ) )
+                end
+
+                # Disable logging
+				MobyUtil::Logger.instance.enabled = false if ( original_logger_state = MobyUtil::Logger.instance.enabled )
+
+				# verify close results
+				begin
+
+					MobyUtil::Retryable.until(
+						:timeout => MobyUtil::Parameter[ self.sut.id ][ :application_synchronization_timeout, '60' ].to_f,
+						:interval => MobyUtil::Parameter[ self.sut.id ][ :application_synchronization_retry_interval, '0.25' ].to_f,
+						:exception => MobyBase::VerificationError,
+						:unless => MobyBase::TestObjectNotFoundError ) {
+
+						# check if the application is still found or not
+						if ( close_options[ :check_process ] == true and @sut.application( :id => self.uid, :__timeout => 0 ) )
+
+							# the application did not close
+							raise MobyBase::VerificationError.new("Verification of close failed. The application that was to be closed is still running.")
+							
+						elsif ( close_options[ :check_process ] == false )
+
+						    if @sut.application( :__timeout => 0 ).uid == self.uid 						
+							  # the application was still in the foreground
+							  raise MobyBase::VerificationError.new("Verification of close failed. The application that was to be closed was still in the foreground.")
+							else
+							  # The foreground application was not the one being closed.
+							  raise MobyBase::TestObjectNotFoundError.new( "The foreground application was not the one being closed (id: #{self.uid})." )
+							end 
+
+						else
+						
+							# The application could not be found, break
+							break;
+
+						end
+
+					}
+
+				rescue MobyBase::TestObjectNotFoundError
+
+					#puts "app.close: sut.application --> test object not found error --> ok --> exit"
+					# everything ok: application not running anymore
+
+				rescue RuntimeError => e
+				
+					
+					if (e.message =~ /The application with Id \d+ is no longer available/)
+						# everything ok: application not running anymore
+					else
+						# something unexpected happened during the close, let exception through
+						raise e
+					end
+
+
+
+				ensure
+
+					# restore original state
+					MobyUtil::Logger.instance.enabled = original_logger_state
+				end
+
+			rescue Exception => exception
+
+				#puts "app.close: close app failed --> exit "
+
+				MobyUtil::Logger.instance.log "behaviour", "FAIL;Failed when closing.;#{ identity };close;"
+				Kernel::raise exception
+
+			end
+
+			#puts "app.close: close app passed --> exit "
+
+			MobyUtil::Logger.instance.log "behaviour", "PASS;Closed successfully.;#{ identity };close;"
+		  #@sut.refresh
+		  @sut.application
+		  nil
+
+		end
+
+		# == description
+		# Returns executable name (exe) of foreground application
+		# === returns
+		# String:: Name(exe) of the application.
+		# === raises
+		# RuntimeError:: No executable name has been defined for this application.
+		# === example
+		#  puts @sut.application.executable_name #prints foreground executable name to console
+		def executable_name
+
+			begin
+
+				exe_name = self.attribute( 'FullName' ).to_s
+
+			rescue MobyBase::AttributeNotFoundError
+
+				begin
+
+					exe_name = self.attribute( 'exepath' ).to_s
+
+				rescue MobyBase::AttributeNotFoundError
+
+					exe_name = ""
+
+				end
+
+			end
+
+			Kernel::raise RuntimeError.new( "No executable full name has been defined for this application." ) if exe_name.empty?
+
+			File.basename( exe_name.gsub( /\\/, '/' ) )
+
+		end
+
+		# == description
+		# Returns uid of foreground application
+		# === returns
+		# String:: UID of the application.		
+		# === example
+		#  puts @sut.application.uid #prints foreground executable uid to console
+		def uid
+
+			id
+
+		end
+		
+		# == description
+		# Indicates whether this application can be closed with the ApplicationBehaviour::close method. Note: at the moment
+		# it always returns true!
+		# === returns
+		# Boolean:: True if closing is possible with the ApplicationBehaviour::close method
+		# === example
+		#  puts @sut.application.closable #prints foreground application closable status to console (at the moment always true)
+		def closable?
+
+			true
+
+		end
+
+		# enable hooking for performance measurement & debug logging
+		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+	end # ApplicationBehaviour
+
+end # MobyBehaviour