Parent page: Using GUI Forms in TestComplete

Even though automation scripts are intended to drive the application under test there are cases when communication with tester is required. With TestComplete, we have a vast arsenal of predefined GUI controls for that (and those, acquainted with Delphi, will be pleasantly surprised by the way it’s organized).

Today’s post provides an example of creating and using dialog with custom event handlers – whenever script user provides input, event handler may be used to provide a customized response.
In the scope of the exercise let’s use the following task.

• Setup form prompts to choose an environment where test plan is to be run
• User can choose one of predefined environments: DEV, SIT, UAT
• Receives a response as a url of the environment
• User can leave suggested by default test data file or can type filepath directly

Preparing Modal Form

We begin with a sample form.

Add Edit Controls, Buttons, and Labels

Set Object Properties

Form

• Name – object name to use in the code; ‘Security’ in my example
• Caption – title of the window when the form is displayed

Label controls

• Caption – displayed text

Edit Box Control

• Name – object name to use in the code; ‘ShowUrl’ in my example
• Text - initial value
• ReadOnly = True – because user can’t input Url directly

Combo Box Control

• Name – object name to use in the code; ‘Environment’/’TestData’ in my example
• Properties.Items – items to select; ‘DEV’, ‘SIT’, ‘UAT’ in my example
• ItemIndex = 0 – initial selection
• Properties.DropDownListStyle = lsFixedList – for Environment combobox
• Properties.DropDownListStyle = lsEditList – for TestData combobox

Buttons

• Caption – displayed text; ‘OK’/’Cancel’ in my example
• Cancel = True – for ‘Cancel’ button
• ModalResult = mrCancel – for ‘Cancel’ button
• Default = True – for ‘OK’ button
• ModalResult = mrOK – for ‘OK’ button

Set Event Handler

Properties

Path

Code

Public Sub Setup_Environment_OnChange(Sender)
  Dim sEnvironment

  sEnvironment = UserForms.Setup.Environment.Text

  Select Case sEnvironment
    Case "DEV"
      UserForms.Setup.ShowUrl.Text = "http://dev/"
      UserForms.Setup.TestData.Text = "W:\Test Suite\Data\DEV.xlsx"
    Case "SIT"
      UserForms.Setup.ShowUrl.Text = "http://sit/"
      UserForms.Setup.TestData.Text = "W:\Test Suite\Data\SIT.xlsx"
    Case "UAT"
      UserForms.Setup.ShowUrl.Text = "http://uat/"
      UserForms.Setup.TestData.Text = "W:\Test Suite\Data\UAT.xlsx"
  End Select

End Sub

Example

Public Function Form1()
  Dim objDlg
  Dim sEnvironment, sTestData
  Dim Result

  'Get object's instance
  Set objDlg = UserForms.Setup

  'Execute
  Result = objDlg.ShowModal

  If Result = mrOK Then
    'retrieve the selected input
    sEnvironment = objDlg.Environment.Text
    sTestData = objDlg.TestData.Text
  Else
    'Respond
    MsgBox "Execution cancelled", vbOKOnly
    'exit function or finalize execution
  End If

End Function

Parent page: Using GUI Forms in TestComplete

Even though automation scripts are intended to drive the application under test there are cases when communication with tester is required. With TestComplete, we have a vast arsenal of predefined GUI controls for that (and those, acquainted with Delphi, will be pleasantly surprised by the way it’s organized).

Today’s post provides an example of creating and using ‘Username/Password’ dialog.
But, first, a couple of words why automation scripts would need one.

No, this is not an authorization to run the scripts. This is for the scripts.
Maybe you need to connect to the database. Or run the scripts with administrator’s permission. Or it’s just a security requirement from your stakeholders.

Whatever it is, you better not store such sensitive data in a file or the source code. Make them exist only during run-time.

Preparing Modal Form

We begin with a sample form.

Add Edit Controls, Buttons, and Labels

Set Object Properties

Form

• Name – object name to use in the code; ‘Security’ in my example
• Caption – title of the window when the form is displayed

Label controls

• Caption – displayed text

Edit Box Controls

• Name – object name to use in the code; ‘EditUsername’/'EditPassword’ in my example
• EditPassword.Properties.EchoMode = eemPassword – to mask password characters

Buttons

• Caption – displayed text; ‘OK’/'Cancel’ in my example
• Cancel = True – for ‘Cancel’ button
• ModalResult = mrCancel - for ‘Cancel’ button
• Default = True – for ‘OK’ button
• ModalResult = mrOK - for ‘OK’ button

Example

  Dim objDlg
  Dim sUsername, sPassword
  Dim Result

  'Get object's instance
  Set objDlg = UserForms.Security

  'Execute
  Result = objDlg.ShowModal

  If Result = mrOK Then
    'retrieve the input
    sUsername = objDlg.EditUsername.Text
    sPassword = objDlg.EditPassword.Text
  Else
    'Respond
    MsgBox "Execution cancelled", vbOKOnly
    'exit function or finalize execution
  End If

Parent page: Using GUI Forms in TestComplete

Even though automation scripts are intended to drive the application under test there are cases when communication with tester is required. With TestComplete, we have a vast arsenal of predefined GUI controls for that (and those, acquainted with Delphi, will be pleasantly surprised by the way it’s organized).

The second post in the series provides an example of using ‘File Open’ dialog.

We begin with a sample form.

Add ‘TOpenDialog’ Icon

Set Dialog Properties

The property names are straight-forward, so I cover only main ones.

• Name – object name to use in the code;
• InitialDir – folder to begin browsing from;
• Filter – to specify what filetypes to display;
• FileName – will contain the full pathname of the file upon successful selection;
• Options\ofPathMustExist – set True if selection accepts only existing files;
• Options\ofFileMustExist - set True if selection accepts only existing files;

These properties can be set in the Property Editor or directly in the code at run-time as in the example below.

Example

'Get object's instance
Set objDlg = UserForms.PlanOpenDlg
'Assign path
objDlg.OpenDialog.InitialDir = "C:\FakePath\Test Plans"
'Set filter
objDlg.OpenDialog.Filter = "XML Test Plans (*.xml)|*.XML"
'Execute as modal and get the status
If objDlg.OpenDialog.Execute Then
  'retrieve the selected file
  sTestPlan = objDlg.OpenDialog.FileName
Else
  'Respond
  MsgBox "Execution cancelled", vbOKOnly
  'exit function or finalize execution
End If

Parent page: Using GUI Forms in TestComplete

Even though automation scripts are intended to drive the application under test there are cases when communication with tester is required. With TestComplete, we have a vast arsenal of predefined GUI controls for that (and those, acquainted with Delphi, will be pleasantly surprised by the way it’s organized).

Today’s post walks through the main preparation steps.

Add New Project Item

Select Project Item Type – ‘User Forms’

Add New Item into ‘User Forms’

Add New Item into ‘User Forms’ – Create a New Form

You end up in the Form Editor

Note that you can add GUI controls from 4 main categories:

• ‘Editors’
• ‘Helpers’
• ‘Extra’
• ‘Dialogs’
• ‘Buttons’

Description 

Get object reference. Get total number of items in the list. Generate an index within the given range. Select item by index.

Implementation

Dim objPage, objList
Dim boolRC
Dim intItemsCount, intRndItem

'Assumptions:
' "Google Advanced Search" page is up
' "Results per page" WebList exists and enabled

'Get page object
Set objPage = Browser("CreationTime:=0").Page("title:=Google Advanced Search")
boolRC = objPage.Exist(0)
If Not boolRC Then
 ExitTest
End If

'Get list object
Set objList = objPage.WebList("name:=num")
boolRC = objList.Exist(0)
If Not boolRC Then
 ExitTest
End If

'Get number of list items
intItemsCount = objList.GetROProperty("items count")
'Create random index
Randomize
intRndItem = CInt(Rnd*intItemsCount)
'Select the item
'Note: selection by index is zero-based
objList.Select "#" & intRndItem

Reference page: Service Functions – System (QTP, VBScript)

Description 

Check folder exists – check folder has files. Iterate through collection of files and keep reference of the most recently modified file (its DateLastModified property is always the highest number). The remaining reference is the one that you need. In case of errors the function returns Nothing. 

Note. In some cases, you may want to use DateCreated or DateLastAccessed properties.

Implementation

Public Function GetLastModifiedFile(ByVal sFolderPath)
  Dim FSO, objFolder, objFile
  Dim objFileResult, longDateTime
  Dim boolRC
 
  Set FSO = CreateObject("Scripting.FileSystemObject")
  boolRC = FSO.FolderExists(sFolderPath)
  If Not boolRC Then
    Set FSO = Nothing
    Set GetLastModifiedFile = Nothing
    Exit Function
  End If

  Set objFolder = FSO.GetFolder(sFolderPath)
  If objFolder.Files.Count = 0 Then
    Set FSO = Nothing
    Set objFolder = Nothing
    Set GetLastModifiedFile = Nothing
    Exit Function
  End If
 
  Set objFileResult = Nothing
  longDateTime = CDate(0)
 
  For Each objFile in objFolder.Files
 
    If objFile.DateLastModified > longDateTime Then
      Set objFileResult = objFile
      longDateTime = objFile.DateLastModified
    End If
   
  Next
 
  Set FSO = Nothing
  Set objFolder = Nothing
  Set GetLastModifiedFile = objFileResult

End Function

Parent page: Service Functions – System (QTP, VBScript)

Question

I need to modify text file template (add a few lines) and “Save as”.

Answer

One of the typical challenges that people face while trying to automate work tasks, is “procedure – result” confusion. Here, the end result* is confused with a way** to do the task.

* What is wanted

Text file with required contents is stored under defined name in required location.

** How it’s done manually

Open text file template in a text editor – add required text – save as new file (select path to store, type in new name).

How to automate

First of all, check that file exists. Create a copy of the template file. If you are not sure that new name and/or location is valid, use error handling. Open text file for appending and add required text. Close file to get it saved.

Note. Sample code below is equally suitable for QTP and TestComplete. 

Implementation

  Dim FSO
  Dim objFile, objTextStream
  Dim boolRC
 
  Set FSO = CreateObject("Scripting.FileSystemObject")

  Call FSO.CopyFile("C:\Temp\template.txt", "C:\Temp\myblog.txt", True)   
  Set objTextStream = FSO.OpenTextFile("C:\Temp\myblog.txt", 8, True)
  objTextStream.WriteLine("http://automation-beyond.com/")
  objTextStream.Close()
 
  Set objTextStream = Nothing
  Set objFile = Nothing
  Set FSO = Nothing

Quick Answers

Quick answers to questions arrived into my blog recently.

How to load GUI map in QTP during run-time?

Use methods of RepositoriesCollection object: Find / Add / Remove. See sample code, read investigation results.

What’s the name of add-in for MS Dynamics Great Plains automation?

There is no specific add-in. You would need Dot NET and Visual Age add-ins to create your own.

How to restore/resize minimized browser window?

You need to retrieve handle of a browser window, then operate the window with standard functions. See sample code (Objective 1 chapter in the article).

How to copy folder with subfolders and files on it?

You can use XCopy.exe or other command line tool. See sample code.

How to create and edit Great Plains Dexterity macros?

1. Enable Advanced macro menu (will appear as Tools/Macro/Advanced) by setting ShowAdvancedMacroMenu=TRUE in Dexterity configuration file Dex.ini.
2. Use Record and Pause commands in Advanced macro menu to create your scripts. Scripts are saved as *.mac files. You can edit source code manually in any text editor.
3. Refer to documentation page to see descriptions for macro commands and operators.

How to enable execution log for  Great Plains Dexterity scripts?

Use logging command. Example: Logging file ‘:c:GP/Log/maclog.txt’
Note non Windows-like syntax.

How to use data from the manually opened Excel file in automation script ?

Manually opened Excel workbook is locked. Editing test data while test execution scripts try using then might mess-up test results. But you can try waiting for a short period of time, then duplicating the file, if uninterruptible execution is required. See sample code.

What is Dictionary object in QTP?

Dictionary is a standard Microsoft object that stores data in key, item pairs.

• You can use Dictionary object as an associative array
• You can use Dictionary object as a dynamic array
• You can use Dictionary object to support optional and default parameters for VBScript functions
• You can use Dictionary object to implement local / global data model in your scripts
• You can use Dictionary object as a container for parameters you pass in/out in QTP Actions

and here’s the related function library.

Answers

Description

Connect to Excel through COM - Open workbook - Open worksheet – map cell values to column names.
Notes.

• Heading and trailing space characters are removed
• To make mapping not case sensitive index is brought to lower case
• If your spreadsheet allows column name duplication you need to enhance the presented code by adding unique index to duplicated column names (i.e. “Name, Name_1, Name_2″)

'Assumptions:
'Excel file exists
'Workbook is open (XLBook)
'Sheet exists
Set objDataRow = CreateObject("Scripting.Dictionary")
'
sSheetIndex = 1
intTargetRow = 123
'
Set objUsedRange = XLBook.Worksheets(sSheetIndex).UsedRange()
'
For Iter = 1 To objUsedRange.Columns.Count
   sCellName = LCase(Trim(objUsedRange.Cells(1,Iter)))
   sCellValue = Trim(objUsedRange.Cells(intTargetRow,Iter))
   objDataRow.Item(sCellName) = sCellValue
   End If
Next

QTP Action at a glance

“Happy Path” Test Flow

The screenprint above demonstrates sample “Test” Flow designed using QTP Actions.
“Happy Path” testing, or conformance testing, or checking can be characterized by 2 attributes: it is scripted, and it ignores everything that is out of scope. Scripted here does not mean a program written in scripting language. It means a predefined sequence of actions to perform. 

Action-centric design

Test Action is not only a sequence of steps to perform. They have to be supported with GUI mapping information to recognize objects and test data to use.
QTP provides first in a form of Object Repository component. Each Action is provided with one or more components of this type. Default, automatically attached component is called “Local” repository. All GUI objects, captured during recording operations, are stored there. Additional components, that saved in separate files (*.TSR), can be attached to a number of Actions; they are named shared repositories. Attached shared repository appears in the list under its file’s name (“Login.tsr” in the example).
Even if the all object references are written in Descriptive Programming notation, Local Repository remains attached to Action.
QTP provides a built-in Data Model that comes in forms of a workbook (DataTable object) and XML structure (Environment object). These objects are global, i.e. accessible from any Action. In addition, QTP automatically creates a worksheet for each new Action created. This worksheet, named after the Action, is associated with it. That creates a convenience of automatically loading Test Data, associated with Actions. 

Declaration and calling mechanism

As QTP Actions are not regular sub-routines, like functions and subs, they have to be declared; that includes requirement to specify arguments that can be passed into Actions.  

User can specify arguments by type, or leave it as variant (“Any” item in Type selection list). Value of an argument can be defaulted, i.e. if it was omitted in the calling statement the Action will receive the default value. This mechanism represents a limited overloading capacity. (Read more about custom implementation of overloading and defaulting with VBScript.)  

Inside Actions, parameters are accessed through Parameter object.  

Parameter object is similar to Dictionary object, but does not support Count property, and methods like Items() or Keys() .  

Last but not least: ExitAction statement allows returning only a constant value.  

Applicability Notes

The built-in QTP framework is designed for non-programmers trying to implement “Happy Path” testing. For that purpose, it fits perfectly. It takes care of initialization and finalization steps, provides ready-to-go structure for test scripts, automatically loads/unloads data associated with the tests, provides rich checking functionalities. It represents evolution of Enhanced Record/Playback approach.  

It is applicable at its best for the following scenarios:  

• small application or application with small independent functionalities that are not cross-tested;
• simple GUI that experiences no fluctuations from build to build;
• straight and simple business logic, with no or minimal number of pop-up dialogs;
• extremely simple test logic, implementing positive, “happy path” test cases, with no branching or looping;
• static dataset, or extremely small number of test data, hard-coded in QTP worksheets.