testability-driver 0.9.2

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

@@ -0,0 +1,182 @@
+############################################################################
+## 
+## 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
+  # SwitchboxBehaviour related behaviour
+  #
+  # == behaviour
+  # GenericSwitchboxBehaviour
+  #
+  # == requires
+  # *
+  #
+  # == input_type
+  # *
+  #
+  # == sut_type
+  # *
+  #
+  # == sut_version
+  # *
+  #
+  # == objects
+  # sut
+  #
+  module SwitchboxBehaviour
+
+    include MobyBehaviour::Behaviour
+
+    # Instructs the SUT to reboot
+    # === params
+    # === returns
+    # === raises
+    def reset
+      str_sleep_time_before_powerup = parameter(:switchbox_sleep_before_powerup_in_reboot)
+      Kernel::raise BehaviourError.new("reboot", "switchbox_sleep_before_powerup_in_reboot not defined for sut in tdriver_parameters.xml") if str_sleep_time_before_powerup == nil
+
+      str_sleep_time_after_powerup = parameter(:switchbox_sleep_after_powerup_in_reboot)
+      Kernel::raise BehaviourError.new("reboot", "switchbox_sleep_after_powerup_in_reboot not defined for sut in tdriver_parameters.xml") if str_sleep_time_after_powerup == nil
+
+      str_commands_after_powerup = parameter(:switchbox_commands_after_powerup_in_reboot)
+
+      begin
+        sleep_time_before_powerup = str_sleep_time_before_powerup.to_i
+        Kernel::raise BehaviourError.new("reboot", "switchbox_sleep_before_powerup_in_reboot need to be non-negative integer smaller than 50 seconds") if sleep_time_before_powerup < 0 or sleep_time_before_powerup > 50
+
+      rescue
+        Kernel::raise BehaviourError.new("reboot", "switchbox_sleep_in_reboot could not be converted to integer")
+      end
+
+      begin
+        sleep_time_after_powerup = str_sleep_time_after_powerup.to_i
+        Kernel::raise BehaviourError.new("reboot", "switchbox_sleep_after_powerup_in_reboot need to be non-negative integer smaller than 500 seconds") if sleep_time_after_powerup < 0 or sleep_time_after_powerup > 500
+
+      rescue
+        Kernel::raise BehaviourError.new("reboot", "switchbox_sleep_after_powerup_in_reboot could not be converted to integer")
+      end
+
+      
+      
+      power_down
+      begin
+        disconnect
+      rescue
+      end
+      sleep sleep_time_before_powerup
+      power_up
+      sleep sleep_time_after_powerup
+
+      MobyUtil::Retryable.until( :timeout => 60, :retry_timeout => 5 ) {
+        system(str_commands_after_powerup) if str_commands_after_powerup != nil
+        if MobyUtil::Parameter[ :ats4_error_recovery_enabled, false ]=='true'
+          MobyUtil::Logger.instance.log "behaviour" , "PASS;TDriver attempting reconnect"
+          self.connect(self.id)
+          MobyUtil::Logger.instance.log "behaviour" , "PASS;TDriver connected"
+        else
+          MobyUtil::Logger.instance.log "behaviour" , "PASS;ATS4 handling reconnection"
+        end
+
+      }
+    end
+
+    # Instructs the switchbox to power down the sut
+    # === params
+    # === returns
+    # === raises
+    def power_down
+      str_command_arr = []
+
+      str_command = parameter(:switchbox_powerdown_command_sequence)
+
+      switchbox_sequence_timeout = parameter(:switchbox_timeout_between_command_sequence)
+
+      Kernel::raise BehaviourError.new("power_down", "switchbox_timeout_between_command_sequence not defined for sut in tdriver_parameters.xml") if switchbox_sequence_timeout == nil
+
+      Kernel::raise BehaviourError.new("power_down", "switchbox_powerdown_command not defined for sut in tdriver_parameters.xml") if str_command == nil
+
+      str_result = parameter(:switchbox_powerdown_command_success_string)
+      Kernel::raise BehaviourError.new("power_down", "switchbox_powerdown_command_success string not defined for sut in tdriver_parameters.xml") if str_result == nil
+
+      #generate the sequence
+      str_command_arr = str_command.split('|')
+
+      #execute switchbox command
+      str_command_arr.each do |foobox_command|
+        MobyUtil::Logger.instance.log "behaviour" , "PASS;Executing powerdown command #{foobox_command}"
+        std_out = system(foobox_command)
+        MobyUtil::Logger.instance.log "behaviour" , "PASS;Powerdown command #{foobox_command} executed"
+        sleep switchbox_sequence_timeout.to_i
+        Kernel::raise BehaviourError.new("power_down", "Failed to power down") unless std_out.to_s.downcase.include?(str_result.to_s.downcase)
+      end
+      @switch_box_power_status = false
+    end
+
+    # Instructs the switchbox to power up the sut
+    # === params
+    # === returns
+    # === raises
+    def power_up
+      str_command_arr = []
+
+      switchbox_sequence_timeout = parameter(:switchbox_timeout_between_command_sequence)
+
+      Kernel::raise BehaviourError.new("power_down", "switchbox_timeout_between_command_sequence not defined for sut in tdriver_parameters.xml") if switchbox_sequence_timeout == nil
+
+      str_command = parameter(:switchbox_powerup_command_sequence)
+      Kernel::raise BehaviourError.new("power_up", "switchbox_powerup_command not defined for sut in tdriver_parameters.xml") if str_command == nil
+
+      str_result = parameter(:switchbox_powerup_command_success_string)
+      Kernel::raise BehaviourError.new("power_up", "switchbox_powerup_command_success string not defined for sut in tdriver_parameters.xml") if str_result == nil
+
+      #generate the sequence
+      str_command_arr = str_command.split('|')
+
+      #execute switchbox command
+      str_command_arr.each do |foobox_command|
+        MobyUtil::Logger.instance.log "behaviour" , "PASS;Executing powerup command #{foobox_command}"
+        std_out = system(foobox_command)
+        MobyUtil::Logger.instance.log "behaviour" , "PASS;Ppowerup command #{foobox_command} executed"
+        sleep switchbox_sequence_timeout.to_i
+        Kernel::raise BehaviourError.new("power_up", "Failed to power up") unless std_out.to_s.downcase.include?(str_result.to_s.downcase)
+      end
+
+      @switch_box_power_status = true
+    end
+
+    # Gets the current power status of the switchbox
+    # === params
+    # === returns
+    # === raises
+    def power_status
+      if @switch_box_power_status == nil
+        false
+      else
+        @switch_box_power_status
+      end
+    end
+
+    # enable hooking for performance measurement & debug logging
+    MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+  end
+
+end
+

data/lib/tdriver/base/sut/generic/behaviours/verification.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 MobyBehaviour
+ 
+  # == description
+  # Defines methods for verification of sut and test object state 
+  #
+  # == behaviour
+  # GenericVerification
+  #
+  # == requires
+  # *
+  #
+  # == input_type
+  # *
+  #
+  # == sut_type
+  # *
+  #
+  # == sut_version
+  # *
+  #
+  # == objects
+  # *;sut
+  #
+	module Verification
+
+		include MobyBehaviour::Behaviour
+
+		# == description
+		# Checks if a child test object matching the given criteria can be found on the sut   
+		# === params
+		# type:: String defining the type of the object
+		# attributes:: (optional) Hash containing attributes that the object must have
+		# === returns
+		# Boolean:: true if the object exists on the sut display
+		# === raises
+		# ArgumentError:: The type argument was not a non-empty String or attributes argument (if provided) was not a Hash
+		# === example
+		# @calc = @sut.run(:name => 'calculator') # launches calculator  
+		# testobj_exists =  @calc.test_object_exists?('Button',{:text => '+',:objectName => 'plusButton'} # check if  test object  with given criteria exists in calculator
+		
+		def test_object_exists?(type, attributes = Hash.new)
+
+			Kernel::raise ArgumentError.new "The type argument must be a non empty String." unless (type.kind_of? String and !type.empty?) 
+			Kernel::raise ArgumentError.new "The attributes argument must be a Hash." unless attributes.kind_of? Hash
+
+			#attributes_with_type = {}.merge attributes
+			attributes_with_type = attributes.clone
+			attributes_with_type[:type] = type
+			attributes_with_type.delete(:__logging)
+
+			#translate the symbol values into string using sut's localisation setting
+			translate!( attributes_with_type )
+
+			identificator = MobyBase::TestObjectIdentificator.new( attributes_with_type )
+
+			original_logging = MobyUtil::Logger.instance.enabled
+			desired_logging = (attributes[:__logging] == nil || attributes[:__logging] == 'false') ? false : true
+			MobyUtil::Logger.instance.enabled = false      
+
+
+			begin
+
+				self.child( attributes_with_type )
+				MobyUtil::Logger.instance.enabled = desired_logging
+				MobyUtil::Logger.instance.log "behaviour" , "PASS;Test object of type #{type} with attributes #{attributes.inspect} was found.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s : ''};test_object_exist;"
+
+			rescue MobyBase::MultipleTestObjectsIdentifiedError
+
+				MobyUtil::Logger.instance.enabled = desired_logging
+				MobyUtil::Logger.instance.log "behaviour" , "PASS;Multiple objects of type #{type} with attributes #{attributes.inspect} were found.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s : ''};test_object_exist;"
+				return true
+
+			rescue MobyBase::TestObjectNotFoundError
+
+				MobyUtil::Logger.instance.enabled = desired_logging
+				MobyUtil::Logger.instance.log "behaviour" , "FAIL;Test object of type #{type} with attributes #{attributes.inspect} was not found.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s : ''};test_object_exist;"
+				return false    
+
+			rescue Exception => e
+
+				MobyUtil::Logger.instance.enabled = desired_logging
+				MobyUtil::Logger.instance.log "behaviour" , "FAIL;Test object of type #{type} with attributes #{attributes.inspect} was not found.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s : ''};test_object_exist;"
+				Kernel::raise e
+
+			ensure
+
+				MobyUtil::Logger.instance.enabled = original_logging
+
+			end
+
+			return true
+
+		end
+
+		# enable hooking for performance measurement & debug logging
+		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+	end # module VerificationBehaviour
+
+end # module MobyBase

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

@@ -0,0 +1,219 @@
+############################################################################
+## 
+## 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 MobyCommand
+
+	class Application < MobyCommand::CommandData
+
+		#TODO: Team TE review @ Wheels
+		#Application command types 
+		#Launch application = :Run 
+		#Close application = :Close 
+		#List of running applications = :List
+		#Current state of the UI = :State
+		#Kill = :Kill
+		#Kill All = :KillAll
+		#
+		# Constructs a new Application CommandData object
+		# == params
+		# command_type:: (optional) Symbol, defines the command to perform on the application
+		# app_name:: (optional) String, name of application to perform this command on
+		# app_uid::
+		# sut:: (optional) SUT, creator of the command. Can be used to access parameters when creating messages.
+		# arguments:: (optional) Arguments given to the application on start up. Comma separated list if more the one.
+		# == returns
+		# Application:: New CommandData object
+		# == raises
+		# ArgumentError:: When the supplied command_type is invalid.
+		def initialize( 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, start_command = nil)
+			# Set status value to nil (not executed)
+
+			self.command( command_type )
+			self.name( app_name )
+			self.uid( app_uid )    
+			self.sut( sut )
+			self.arguments( arguments )
+			self.events_to_listen( events_to_listen )
+			self.signals_to_listen( signals_to_listen )
+			self.environment( environment )
+			self.flags( flags )
+			self.start_command( start_command )
+		    self.refresh_args
+
+			@_attribute_csv_string = nil
+
+			self
+
+		end
+
+		# Store the args for possible future use
+		def refresh_args(refresh_args={})
+		  @_refresh_args = refresh_args
+		end
+		
+		def get_refresh_args
+		  @_refresh_args
+		end
+
+
+		# Defines the type of command this Application CommandData object represents
+		# == params
+		# command_type:: Symbol, defines the command to perform on the application
+		# == returns
+		# Application:: This CommandData object
+		# == raises
+		# ArgumentError:: When the supplied command_type is invalid.
+		def command( command_type )        
+
+			@_command = command_type
+			self    
+
+		end  
+
+		# Defines the used SUT to be able to access parameters when creating messages
+		# == params
+		# sut:: SUT, creator of the command.
+		# == returns
+		# Application:: This CommandData object
+		# == raises
+		# ArgumentError:: When sut is not nil or a SUT
+		def sut( sut )
+
+			raise ArgumentError.new( "The given sut must be nil or a SUT." ) unless sut == nil || sut.kind_of?( MobyBase::SUT )
+			@_sut = sut
+			self
+
+		end
+
+		# Defines the name of the application this Application CommandData object is associated with
+		# == params
+		# app_name:: String, name of application to perform this command on
+		# == returns
+		# Application:: This CommandData object
+		# == raises
+		# ArgumentError:: When app_name is not nil or a String
+		def name( app_name )    
+
+			raise ArgumentError.new( "The given application name must be nil or a String." ) unless app_name == nil || app_name.kind_of?( String )        
+			@_application_name = app_name    
+			self
+
+		end
+
+		def arguments( arguments )
+
+			raise ArgumentError.new( "The given application arguments must be nil or a String." ) unless arguments == nil || arguments.kind_of?( String )   
+			@_arguments = arguments
+
+		end
+
+		def flags( flags ) 
+
+			raise ArgumentError.new( "The given application flags must be nil or a Hash." ) unless flags == nil || flags.kind_of?( Hash )   
+			@_flags = flags
+
+		end
+
+		def environment( environment )
+
+			raise ArgumentError.new( "The given application environment must be nil or a String." ) unless environment == nil || environment.kind_of?( String )   
+			@_environment = environment
+
+		end
+
+		def events_to_listen( events )
+
+			raise ArgumentError.new( "The events to listen must be nil or a String." ) unless events == nil || events.kind_of?( String )   
+			@_events_to_listen = events
+
+		end
+
+		def signals_to_listen( signals )
+
+			raise ArgumentError.new( "The signals to listen must be nil or a String." ) unless signals == nil || signals.kind_of?( String )   
+			@_signals_to_listen = signals
+
+		end
+		
+		def start_command( start_command )
+
+			raise ArgumentError.new( "The start_command must be nil or a String." ) unless start_command == nil || start_command.kind_of?( String )   
+			@_start_command = start_command
+
+		end
+
+		# Defines the uid of the application this Application CommandData object is associated with
+		# == params
+		# app_uid:: FixNum, uid of application to perform this command on
+		# == returns
+		# Application:: This CommandData object
+		# == raises
+		# ArgumentError:: When app_name is not nil or a String
+		def uid( app_uid )       
+
+			raise ArgumentError.new( "The given application uid must be nil, a String or an Integer." ) unless app_uid == nil || app_uid.kind_of?( String ) || app_uid.kind_of?( Fixnum )
+			@_application_uid = app_uid
+			@_application_uid = @_application_uid.to_i unless @_application_uid == nil    
+			self    
+
+		end
+
+		def get_command
+
+			@_command
+
+		end
+
+		def get_application
+
+			@_application_name
+
+		end
+
+		def get_uid
+
+			@_application_uid
+
+		end
+
+		def get_flags
+
+			@_flags
+
+		end
+
+		def attribute_filter(attribute_string)
+
+			@_attribute_csv_string = attribute_string
+
+		end
+
+		def get_attribute_filter
+
+			@_attribute_csv_string
+
+		end
+
+		# enable hooking for performance measurement & debug logging
+		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+	end # Application
+
+end # MobyCommand