UFT Object Identification: Test Object Model

Mastering Object Identification in UFT: Understanding the Test Object Model

Object identification is the cornerstone of successful test automation with Unified Functional Testing (UFT), enabling the tool to recognize and interact with application elements during test execution. The Test Object Model serves as the foundation for this process, providing a structured framework that represents the various controls and components within your application as programmable objects.

Introduction to UFT and Object Identification

Unified Functional Testing, formerly known as QuickTest Professional (QTP), is a widely used automated testing solution that supports functional and regression testing for various applications. The power of UFT lies in its ability to identify and interact with objects in applications, a capability made possible through its sophisticated object identification mechanism. When recording or running tests, UFT maps the objects in your application to corresponding test objects in its Test Object Model, allowing it to perform operations on these objects using methods and properties specific to their class.

Object identification is essentially how UFT distinguishes one element from another in your application. Each object in the application is associated with a test object class that defines its properties and methods. This relationship enables UFT to understand what actions can be performed on each object and how to locate it during test execution. Without proper object identification, tests would be unreliable and prone to failures, especially when applications undergo changes or updates.

Understanding the Test Object Model is crucial for developing effective test automation solutions that can accurately interact with application elements during test execution. By mastering object identification, automation professionals can create robust and reliable test scripts that withstand application changes and provide consistent results.

Understanding the Test Object Model in UFT

The Test Object Model (TOM) in UFT serves as the foundation for how the tool recognizes and interacts with various objects in applications under test. It represents a hierarchical structure of object types or classes that correspond to the components present in your application. Each test object class within this model contains a predefined set of properties that describe the object, along with methods that can be performed on it.

When you record a test in UFT, the tool automatically creates test objects based on the Test Object Model. These test objects are representations of the actual objects in your application, such as buttons, text boxes, and dropdown menus. The model organizes these objects into classes with associated properties and methods, allowing UFT to understand how to interact with them during test execution.

The Test Object Model is extensive, covering a wide variety of object types from standard GUI controls to specialized objects in web, mobile, and enterprise applications. This comprehensive nature makes UFT a versatile tool for automated testing across different platforms and technologies.

• Test Object Model components:
• Object classes (e.g., Button, Window, Dialog)
• Properties (descriptive attributes)
• Methods (actions that can be performed)

Each test object class in the model corresponds to a specific type of object in your application, such as buttons, text boxes, or checkboxes. For example, a "WebButton" test object class represents all button controls in web applications, while a "WinCheckBox" class represents checkbox controls in Windows applications. Each class has a predefined set of properties that UFT uses to identify objects during test execution, as well as methods that can be performed on objects of that class.

• The Test Object Model includes:
• Predefined object classes for various application types
• Properties that describe object characteristics
• Methods that define operations that can be performed on objects
• A hierarchical structure that reflects relationships between objects

Understanding the TOM is crucial for creating stable and maintainable tests. When you know how UFT perceives objects, you can write tests that are more resilient to changes in the application under test, reducing maintenance overhead and increasing test reliability.

The Object Identification Process in UFT

The object identification process in UFT follows a well-defined workflow that ensures accurate and reliable object recognition. When a test runs, UFT first attempts to identify objects using the mandatory properties defined in the Test Object Model. If these properties are sufficient to uniquely identify the object, the process concludes successfully, and UFT proceeds with the specified operation.

If the mandatory properties do not result in a unique identification, UFT then incorporates the assistive properties into the identification process. These additional properties help narrow down the candidates to find the correct object. In cases where both mandatory and assistive properties fail to provide a unique identification, UFT activates its Smart Identification feature.

Smart Identification uses a sophisticated algorithm that applies a set of filter properties and base properties to identify the object. This mechanism provides an extra layer of resilience, allowing tests to continue even when the standard identification methods fail. Understanding this workflow helps testers create more robust tests that can adapt to minor application changes.

• Object identification workflow steps:

1. Use mandatory properties for identification

2. If not unique, use assistive properties

3. If still not unique, apply Smart Identification

4. If all methods fail, report an error

When UFT encounters an object during test execution or recording, it follows a systematic process to identify and map the object to its corresponding test object class. This process begins when UFT attempts to locate an object based on the properties specified in your test script. UFT first checks the object's class and then compares its properties against those defined in the Test Object Model to find a match.

The object identification process involves several steps. First, UFT determines the object's class by examining its type and characteristics. Then, it collects a set of description properties that describe the object. These properties may include the object's name, type, location, and other attributes that help distinguish it from other similar objects. UFT then compares these properties against the properties defined in the Test Object Model to find a unique match.

• Key steps in object identification:
• Determining the object's class
• Collecting description properties
• Comparing properties against the Test Object Model
• Selecting the best matching object

If multiple objects match the description properties, UFT uses additional mechanisms to select the most appropriate object, such as ordinal identifiers or the Smart Identification mechanism. This process ensures that UFT can reliably identify objects even when the application undergoes minor changes, making your tests more robust and maintainable.

Properties and Methods in the Test Object Model

Properties and methods form the core of the Test Object Model, defining how UFT interacts with objects in your application. Properties are characteristics or attributes of an object that describe its state or appearance, such as its name, text, location, or color. Methods, on the other hand, are actions that can be performed on an object, such as Click, Set, or GetROProperty.

Each test object class has a predefined set of properties that UFT uses to identify objects during test execution. These properties are divided into two categories: mandatory and assistive. Mandatory properties are those that are always used to identify objects, while assistive properties are used when mandatory properties are not sufficient to create a unique description. The "Test Object Description" defines the set of properties that UFT learns during recording, while the "Runtime Object Description" represents the actual properties of the object during test execution.

Methods define the operations that can be performed on objects. For example, the "Click" method can be used to simulate a mouse click on a button, while the "Set" method can be used to enter text into a text field. Understanding the available methods for each object class allows you to create comprehensive tests that cover all the functionality of your application.

' Example of using properties and methods in UFT
' Clicking a button using its name property
Browser("MyApplication").Page("HomePage").WebButton("Submit").Click

' Setting text in a text field using the Set method
Browser("MyApplication").Page("HomePage").WebEdit("Username").Set "testuser"

' Getting the value of a runtime property
Dim pageTitle
pageTitle = Browser("MyApplication").Page("HomePage").GetROProperty("title")

The Test Object Model provides a rich set of properties and methods for different object types. Some properties are common across multiple object classes, while others are specific to certain objects. Understanding the available properties and methods for different object types is essential for creating effective test scripts that accurately simulate user interactions.

' Example of object identification in UFT
' This code demonstrates how to identify a web button using the Test Object Model
Set webButton = Browser("MyBrowser").Page("MyPage").WebButton("Submit")
webButton.Click

' Another example with more specific identification
Set loginButton = Browser("MyBrowser").Page("MyPage").WebButton("name:=btnLogin", "html id:=submitBtn")
loginButton.Click

' Example of using properties and methods in UFT
' Getting properties of a web button
Set btn = Browser("MyBrowser").Page("MyPage").WebButton("Submit")
buttonName = btn.GetROProperty("name")
buttonText = btn.GetROProperty("innertext")

' Using methods to interact with objects
btn.Set "New Value"  ' For text fields
btn.Click           ' For buttons
btn.Select "Option" ' For dropdowns

Configuring Object Identification Settings

UFT provides several settings that allow you to customize the object identification process to suit your testing needs. These settings control how UFT learns and stores object properties, which properties it uses for identification, and how it handles objects that cannot be uniquely identified. Proper configuration of these settings is essential for creating reliable and maintainable tests.

The Object Identification settings can be accessed through the Object Identification dialog box, where you can configure properties for each test object class. For each class, you can specify which properties should be used for mandatory identification and which should be used as assistive properties. You can also set the number of assistive properties UFT should learn and the time it should spend learning these properties.

• Key configuration options:
• Setting mandatory and assistive properties for each object class
• Configuring the Smart Identification mechanism
• Adjusting the learning behavior for test objects
• Managing ordinal identifiers for objects with similar properties

The Smart Identification mechanism is particularly useful when objects cannot be uniquely identified using their learned properties. When enabled, Smart Identification uses a set of base and filter properties to create a more robust description that can withstand minor changes in the application. By configuring these settings appropriately, you can ensure that your tests remain stable even when the application undergoes changes.

Best Practices for Effective Object Identification

Implementing effective object identification strategies is crucial for creating reliable and maintainable automated tests. Following best practices in this area can significantly improve the stability and longevity of your test scripts, reducing maintenance overhead and increasing test coverage.

One important practice is to use descriptive object names that clearly indicate the object's purpose and location in the application. This makes tests easier to understand and maintain. Additionally, you should avoid using properties that are likely to change, such as absolute coordinates or dynamically generated values. Instead, focus on stable properties like the object's name, type, or associated text.

Another best practice is to leverage the Test Object Model effectively by understanding the properties and methods available for each object class. This allows you to write more precise tests that interact with objects in the intended manner. You should also consider using regular expressions and other advanced identification techniques to handle objects with varying properties or dynamic content.

' Example of using regular expressions for object identification
' Using a regular expression to match buttons with similar names
Browser("MyApplication").Page("HomePage").WebButton("btn_.*").Click

' Using the ChildObjects method to handle dynamic objects
Set allLinks = Browser("MyApplication").Page("HomePage").ChildObjects(objLink)
For i = 0 to allLinks.Count - 1
    If allLinks(i).GetROProperty("innertext") = "Click Me" Then
        allLinks(i).Click
        Exit For
    End If
Next

• Best practices for object identification:
• Use unique and stable properties
• Avoid dynamic properties when possible
• Regularly review and update object repositories
• Use descriptive naming conventions for test objects

Regular testing and maintenance of your object identification strategies are also essential. As applications evolve, objects may change, requiring updates to your test scripts. By regularly reviewing and updating your object identification approaches, you can ensure that your tests remain effective and reliable over time.

Troubleshooting Object Identification Issues

Despite careful planning, object identification issues can occur in UFT tests. When objects are not recognized properly, tests may fail or behave unpredictably. Common causes of identification issues include changes in the application's UI, incorrect property usage, or objects being created dynamically during runtime.

To troubleshoot these issues, start by using the Object Identification settings in UFT to adjust the mandatory and assistive properties for specific object classes. You can also enable the Smart Identification feature to provide additional flexibility during object recognition. For complex scenarios, consider using programmatic identification with descriptive programming techniques, which offer more control over the object identification process.

Regular maintenance of test objects is essential to ensure continued reliability as applications evolve. This involves updating object repositories, adjusting identification properties, and refactoring test scripts as needed. By proactively addressing object identification issues, testers can maintain the stability and effectiveness of their automation efforts.

' Example of programmatic identification in UFT
' Using descriptive programming to identify objects
Set objDesc = Description.Create()
objDesc("micclass").Value = "WebButton"
objDesc("name").Value = "Submit"
objDesc("html tag").Value = "BUTTON"

Set allButtons = Browser("MyBrowser").Page("MyPage").ChildObjects(objDesc)

For i = 0 to allButtons.Count - 1
    If allButtons(i).GetROProperty("innertext") = "Submit" Then
        allButtons(i).Click
        Exit For
    End If
Next

Conclusion

Object identification in UFT, powered by the Test Object Model, forms the foundation of robust test automation. By understanding how UFT recognizes and interacts with objects, you can create tests that are not only effective but also resilient to changes in the application under test. Mastering the Test Object Model and implementing best practices for object identification will significantly enhance the quality and maintainability of your automated tests.

As you continue to work with UFT, remember that object identification is both an art and a science. It requires a deep understanding of the tool's capabilities, as well as careful consideration of the application's structure and behavior. By investing time in mastering these concepts, you'll be well-equipped to build sophisticated test automation frameworks that deliver consistent and reliable results.

Object Identification in UFT - Test Object Model is a critical aspect of creating reliable and maintainable automated tests. By understanding how the Test Object Model works, mastering the object identification process, and implementing best practices, testers can develop robust automation solutions that withstand application changes. With proper knowledge and techniques, object identification can transform from a potential challenge into a powerful advantage in your test automation strategy.

Frequently Asked Questions

• What is the Test Object Model in UFT?
  The Test Object Model (TOM) in UFT is a hierarchical structure that represents application objects as programmable entities with predefined properties and methods. It serves as the foundation for how UFT recognizes and interacts with various objects in applications under test.
• How does UFT identify objects during test execution?
  UFT follows a systematic process using mandatory properties first, then assistive properties if needed, and finally Smart Identification if both fail. This multi-step approach ensures accurate object recognition even when applications undergo minor changes.
• What are the differences between mandatory and assistive properties?
  Mandatory properties are always used for object identification in UFT, while assistive properties are used when mandatory properties don't provide a unique identification. Assistive properties help narrow down candidates to find the correct object when multiple matches exist.
• How can I improve object identification in my UFT tests?
  Use unique and stable properties like object names rather than dynamic values, implement descriptive programming techniques, regularly update object repositories, and configure Smart Identification settings to handle application changes effectively.
• What is Smart Identification in UFT?
  Smart Identification is UFT's advanced feature that uses filter and base properties to identify objects when standard identification methods fail. It provides an extra layer of resilience, allowing tests to continue even when the application undergoes minor changes.