Mastering Object Identification in UFT

Mastering Object Identification in UFT: A Comprehensive Guide to Identifying Objects in Ajax and Web Applications

Object identification is the cornerstone of successful test automation in Unified Functional Testing (UFT), especially when dealing with modern web applications that employ Ajax and dynamic content. This comprehensive guide explores how UFT identifies objects in complex web environments, the challenges it faces, and the techniques to overcome these challenges.

Understanding Object Identification in UFT

Object identification in UFT refers to the process by which the test tool recognizes and interacts with various UI elements within an application under test. When creating automated tests, UFT needs to uniquely identify each object to perform actions like clicking buttons, entering text, or verifying properties. This process becomes particularly challenging in modern web applications that utilize Ajax technology, which dynamically updates content without full page reloads.

Unlike traditional web pages where elements remain relatively static, Ajax applications can change their structure and content on the fly, making object identification more complex. UFT employs a sophisticated mechanism to handle these scenarios, ensuring that tests remain reliable and maintainable despite the dynamic nature of modern web applications.

In traditional web applications, objects are typically static and have consistent properties, making them easier to identify. However, modern web applications, especially those using Ajax, present unique challenges due to their dynamic nature. Objects may appear, disappear, or change properties based on user actions or server responses, requiring more sophisticated identification techniques.

The Object Identification Process in UFT

UFT follows a systematic approach to identify objects in your application. When a test script references an object, UFT first checks the Object Repository to find a matching description. If a unique match is found, the process completes successfully. If multiple objects match the description, UFT employs additional properties to narrow down the selection.

The identification process typically involves these steps:

• UFT first attempts to match the object using mandatory properties
• If multiple objects match, assistive properties are used to differentiate
• If still ambiguous, ordinal identifiers may be employed
• Finally, Smart Identification can be used as a fallback mechanism

This multi-layered approach ensures that UFT can handle a wide variety of application scenarios. The properties used for identification can include both standard web properties like "id", "name", and "tag" as well as custom properties defined by the user. Understanding how UFT prioritizes these properties is crucial for creating reliable tests that can withstand minor application changes.

' Example of defining object properties in UFT
Set objDescription = Description.Create()
objDescription("micclass").Value = "WebButton"
objDescription("name").Value = "Submit"
objDescription("html tag").Value = "BUTTON"

' Using the description to find an object
Set submitButton = Browser("Browser").Page("Page").ChildObjects(objDescription)
If submitButton.Count > 0 Then
    submitButton(0).Click
Else
    Reporter.ReportEvent 1, "Object Not Found", "Submit button was not identified"
End If

The object identification process in UFT follows a systematic workflow that ensures reliable object recognition during test execution. When UFT runs a test, it attempts to locate objects in your application using a predefined set of criteria. If the first attempt fails, UFT employs fallback mechanisms to identify the object, ensuring test stability and reliability.

Here's how the process typically works:

1. UFT first checks the Object Repository for test object definitions

2. It attempts to match the object using the properties defined in the test object

3. If a direct match isn't found, UFT may use ordinal identifiers (like location or index)

4. As a last resort, UFT can employ Smart Identification to locate similar objects

This multi-layered approach allows UFT to handle various scenarios, including applications with dynamic content or objects that change between test runs. For Ajax applications, this process is particularly important because objects may load asynchronously and may not be immediately available when the test attempts to interact with them.

Handling Ajax Applications with UFT

Ajax (Asynchronous JavaScript and XML) presents unique challenges for object identification in UFT. Unlike traditional web applications that load entire pages, Ajax applications update specific portions of the page dynamically, often without a full page refresh. This dynamic behavior can cause timing issues where UFT attempts to interact with an object before it's fully loaded or visible. To address these challenges, UFT provides several synchronization mechanisms that ensure tests interact with objects only when they're ready.

When working with Ajax applications in UFT, several techniques can improve object identification:

• Synchronization Points: Insert Wait statements or synchronization points to pause test execution until objects are ready for interaction
• Dynamic Property Handling: Configure objects to use dynamic properties that may change between test runs
• Ajax Test Settings: Adjust UFT's Ajax test settings to properly handle asynchronous content loading

' Example of synchronization in Ajax testing with UFT
' Method 1: Wait for a specific object to appear
Browser("Browser").Page("Page").Sync
Browser("Browser").Page("Page").WebButton("dynamic_button").WaitProperty "visible", True, 10000

' Method 2: Use a synchronization point
Wait 5 ' Wait for 5 seconds

' Method 3: Wait for a specific property value
Browser("Browser").Page("Page").WebEdit("ajax_field").WaitProperty "value", "loaded", 20000

' Method 4: Use a custom synchronization function
Function WaitForAjaxComplete()
    Dim startTime, endTime
    startTime = Timer
    endTime = startTime + 30 ' Wait up to 30 seconds
    
    Do While Timer < endTime
        If Browser("Browser").Page("Page").WebButton("loading_indicator").Exist = False Then
            WaitForAjaxComplete = True
            Exit Function
        End If
        Wait 1
    Loop
    
    WaitForAjaxComplete = False
End Function

' Using the custom synchronization function
If WaitForAjaxComplete() Then
    Browser("Browser").Page("Page").WebButton("submit_button").Click
Else
    Reporter.ReportEvent 1, "Ajax Timeout", "Ajax operation did not complete within the expected time"
End If

Another approach is to use the Object Identification Center to configure properties specific to Ajax objects:

' Configure Ajax object identification
Browser("MyBrowser").Page("MyPage").WebElement("AjaxElement").ObjectIdentification "micClass", "WebElement", _
    "html tag", "DIV", _
    "innertext", "Loading...", _
    "timeout", 5000

Object Identification Center (OIC)

The Object Identification Center (OIC) is a powerful tool within UFT that enables testers to create unique and robust object identifications. OIC provides a visual interface to examine how UFT identifies objects in your application and to modify the identification properties as needed. With OIC, you can:

• View the properties and values that UFT uses to identify an object
• Add or remove properties from the description
• Set mandatory and assistive properties
• Test your object identification to ensure it's unique

OIC is particularly useful when dealing with complex objects or when standard identification methods fail. By allowing you to fine-tune object descriptions, OIC helps create tests that are more reliable and maintainable. The tool also enables you to save time by automatically suggesting properties that can uniquely identify an object based on its characteristics. When used effectively, OIC can significantly improve the quality of your automated tests by ensuring that objects are identified consistently across different test runs.

The Object Identification Center in UFT is a centralized interface that allows you to view, modify, and configure the properties that UFT uses to identify objects, making it easier to handle complex scenarios like those found in Ajax applications.

Through the OIC, you can:

• View and modify the mandatory and assistive properties for each object type
• Configure Smart Identification properties as a fallback mechanism
• Export and import object identification configurations
• Test your identification settings to ensure they work correctly

When working with Ajax applications, the OIC becomes particularly valuable because it allows you to configure properties that account for the dynamic nature of these applications. For example, you might set properties that identify objects based on their behavior rather than their static attributes.

' Configure custom object identification properties
Set objDesc = Description.Create()
objDesc("micClass").Value = "WebElement"
objDesc("html tag").Value = "DIV"
objDesc("innertext").Value = "Dynamic Content"
objDesc("timeout").Value = 5000

' Use the configured description to identify an object
Set dynamicElement = Browser("MyBrowser").Page("MyPage").ChildObjects(objDesc)(0)

Smart Identification Mechanism

Smart Identification is a powerful fallback mechanism in UFT that kicks in when the primary object identification fails. This feature allows UFT to make educated guesses about which object you're trying to interact with by using a set of base filter properties and optional associated properties.

When UFT cannot identify an object using the properties defined in the Object Repository, it automatically attempts to use Smart Identification if it's enabled. The Smart Identification process works as follows:

1. UFT filters objects based on the base filter properties

2. If multiple objects match the base filter, it applies the optional associated properties

3. If a unique match is found, UFT uses that object

4. If no unique match is found, the test fails with a "Cannot identify the object" error

For Ajax applications, Smart Identification can be particularly useful because it can identify objects even when their properties change dynamically. By carefully selecting base filter and associated properties that are likely to remain stable despite changes in the application, you can create tests that are more resilient to UI modifications.

' Example of Smart Identification in UFT
Set objDescription = Description.Create()
objDescription("micclass").Value = "WebEdit"
objDescription("name").Value = "username_field"
' Remove standard identification properties
objDescription("index").Value = 0
objDescription("html id").Value = ""
objDescription("name").Value = ""

' Enable Smart Identification
objDescription("smart identification").Value = True

' Using Smart Identification to find an object
Set usernameField = Browser("Browser").Page("Page").ChildObjects(objDescription)
If usernameField.Count > 0 Then
    usernameField(0).Set "testuser"
Else
    Reporter.ReportEvent 1, "Smart Identification Failed", "Username field could not be identified"
End If

Another advanced technique is Virtual Object Identification, which allows you to map non-standard objects (like Java applets or Flash objects) to standard UFT objects. This technique is particularly useful when dealing with legacy applications or custom controls that don't conform to standard web object models.

Best Practices for Object Identification in UFT

Creating effective object identifications requires careful planning and consideration. Here are some best practices to follow:

• Use descriptive object names that clearly indicate what the object represents
• Limit the number of properties in your object descriptions to avoid unnecessary complexity
• Regularly review and update your object repository to ensure it remains accurate
• Test your object identification in different environments to verify its robustness

Maintaining a well-organized Object Repository is crucial for the long-term success of your automated tests. A good practice is to modularize your object repository by separating objects based on functionality or application modules. This approach makes it easier to manage and update your objects as the application evolves.

Additionally, when dealing with dynamic content, consider using regular expressions or other pattern matching techniques to create more flexible object descriptions. This approach can help your tests adapt to minor changes in the application without requiring constant updates.

For Ajax applications specifically, implement proper synchronization techniques to ensure objects are fully loaded before interaction. Avoid hard-coded wait times where possible, and instead use property-based synchronization that adapts to the application's actual state.

Conclusion

Object identification in UFT is a critical component of successful test automation, especially for modern web applications that utilize Ajax and dynamic content. By understanding how UFT identifies objects, leveraging advanced techniques like Smart Identification and the Object Identification Center, and following best practices, you can create robust and maintainable automated tests.

The systematic approach that UFT takes to object identification—using mandatory properties, assistive properties, ordinal identifiers, and Smart Identification—provides a multi-layered defense against the challenges of dynamic web applications. When working specifically with Ajax applications, proper synchronization techniques and thoughtful object configuration become even more important to ensure reliable test execution.

As web applications continue to evolve with more dynamic content and complex interactions, mastering object identification in UFT becomes increasingly important for ensuring the reliability and effectiveness of your test automation efforts. By implementing the techniques and best practices outlined in this guide, you'll be well-equipped to handle even the most challenging object identification scenarios in modern web applications.

Frequently Asked Questions

• What is object identification in UFT?
  Object identification in UFT is the process by which the test tool recognizes and interacts with various UI elements within an application under test. This is crucial for performing automated actions like clicking buttons, entering text, or verifying properties.
• How does UFT handle objects in Ajax applications?
  UFT handles Ajax applications through synchronization mechanisms that ensure tests interact with objects only when they're ready. Techniques include using Wait statements, dynamic property handling, and adjusting Ajax test settings to properly manage asynchronous content loading.
• What is Smart Identification in UFT?
  Smart Identification is a fallback mechanism that activates when primary object identification fails. It uses base filter properties and optional associated properties to make educated guesses about which object to interact with, providing resilience against dynamic content changes.
• What is the Object Identification Center in UFT?
  The Object Identification Center is a visual tool that allows testers to create unique and robust object identifications. It enables viewing and modifying properties that UFT uses to identify objects, setting mandatory and assistive properties, and testing object identification for uniqueness.
• What are best practices for object identification in UFT?
  Best practices include using descriptive object names, limiting properties in descriptions, regularly updating the object repository, and implementing proper synchronization for dynamic content. Modularizing the object repository and using pattern matching techniques also improve test maintainability.