Mastering Object Identification in UFT

Mastering Object Identification in UFT - Advanced Object Repository Management and Optimization

Object identification is the cornerstone of successful automation testing with Unified Functional Testing (UFT), forming the critical bridge between test scripts and application under test. Understanding and optimizing how UFT identifies objects can dramatically improve test stability, maintenance efficiency, and overall execution performance.

Introduction to Object Identification in UFT

Object identification in UFT refers to the mechanism by which the tool recognizes and interacts with elements within an application's user interface. When you record a test, UFT captures properties of objects and stores them in the Object Repository, creating a mapping between test objects and real application objects. This process enables UFT to locate and interact with objects during test execution.

The effectiveness of your automation scripts hinges on how well UFT can uniquely identify objects consistently across different test runs and environments. As applications evolve, maintaining this identification accuracy becomes increasingly challenging, making advanced object repository management essential for sustainable automation frameworks.

The object identification process involves several key components:

• Test Objects: UFT's representation of application objects
• Object Repository: A storage location for object properties
• Descriptive Programming: A method to identify objects without using the object repository
• Ordinal Identifiers: Fallback mechanisms when regular properties fail

UFT identifies objects using a combination of mandatory and assistive properties. Mandatory properties are those that UFT considers essential for uniquely identifying an object, while assistive properties are additional properties that help distinguish between similar objects.

Understanding the Object Repository in UFT

The Object Repository serves as UFT's memory, storing descriptions of objects that your tests interact with. It contains properties that UFT uses to identify objects during test execution. When working with object repositories, it's crucial to understand that UFT doesn't store all available properties of an object. Instead, it selects a minimal set of properties that uniquely identify the object, balancing identification accuracy with repository size and performance. This selective approach prevents repository bloat and reduces execution time while ensuring reliable object recognition.

Key points about Object Repositories:

• Stores object descriptions used for identification during test execution
• Exists in two forms: local (test-specific) and shared (reusable across tests)
• Uses a minimal set of properties to ensure unique identification

Object Repository Types and Their Uses

In UFT, object repositories can be categorized into two main types: local and shared repositories, each serving different purposes in test automation projects.

Local repositories are embedded within individual test files and contain objects specific to those tests. They're ideal for small projects or when objects are used in only one test. The primary advantage is simplicity and independence, but they become difficult to manage as the number of tests grows.

Shared repositories, on the other hand, can be used across multiple tests and are stored as separate files. They offer better maintainability, consistency, and reusability of objects. Shared repositories are particularly beneficial in large projects where the same objects appear in multiple tests.

When working with multiple shared repositories, it's crucial to establish clear naming conventions and organizational structures. This helps prevent conflicts and makes it easier to locate and modify objects. Additionally, implementing version control for object repositories ensures that changes are tracked and can be reverted if necessary. The Object Repository Manager window in UFT allows you to open multiple shared repositories simultaneously, making it easier to manage and modify objects across different repositories. This tool enables operations like copying objects between repositories, adding new objects, and updating existing ones.

Advanced Object Repository Management Techniques

Effective object repository management goes beyond basic storage and retrieval of object descriptions. Advanced techniques include implementing a hybrid repository model, combining local and shared repositories strategically. This approach allows you to leverage the benefits of both: using shared repositories for common objects across multiple tests while maintaining local repositories for test-specific objects.

Another advanced technique is the use of object repositories with parameters, enabling dynamic object identification based on runtime values. Regular maintenance is essential for repository health. This includes periodically reviewing and updating object properties, removing redundant objects, and consolidating similar repositories.

' Opening a shared object repository
Set objRepo = ObjectRepositoryUtil.Open("C:\SharedRepositories\Login_OR.tsr")

' Adding a new object to the repository
Set newObject = objRepo.AddObject("btnSubmit", "Button")
newObject.Properties("name").Value = "Submit"
newObject.Properties("html tag").Value = "INPUT"

' Saving the modified repository
objRepo.Save

When working with object repositories, it's also beneficial to implement object repository checkpoints. These checkpoints verify that objects exist and have the expected properties during test execution. They help detect application changes that might affect test stability.

' Example of advanced object repository management
' This script demonstrates how to work with shared repositories
Set ORManager = ObjectRepositoryUtil.GetRepositoryManager

' Open a shared object repository
Set sharedRepo = ORManager.OpenRepository("C:\Repositories\CommonObjects.tsr")

' Add a new object to the shared repository
Set newObject = sharedRepo.AddObject("LoginButton", "Button", _
    "properties", "name:=LoginButton;html id:=btnLogin", _
    "description", "The main login button on the application")

' Save and close the repository
sharedRepo.Save
sharedRepo.Close

' Use the shared repository in a test
Set loginButton = ObjectRepositoryUtil.GetObject("LoginButton")
Browser("MyApp").Page("LoginPage").WebButton(loginButton).Click

Optimization Strategies for Object Repositories

Optimizing object repositories is essential for maintaining efficient test execution and minimizing resource consumption. Poorly optimized repositories can lead to slow test runs, increased memory usage, and maintenance challenges.

One key optimization strategy is to minimize the number of properties stored for each object. By carefully selecting the minimal set of properties required for unique identification, you can reduce repository size and improve performance.

Another optimization approach is to use regular expressions when defining object properties. Regular expressions allow for more flexible matching of object properties, reducing the need for multiple entries with slight variations. For example, you can use a regular expression like "Window\d+" to match windows with names like "Window1", "Window2", etc.

' Using regular expressions for object identification
Browser("MyApp.*").Page("Page.*").WebEdit("username_.*").Set "testuser"

Object repository maintenance is another critical aspect of optimization. Regularly reviewing and cleaning up unused objects, consolidating similar objects, and updating obsolete references helps keep the repository lean and efficient.

• Regular repository audits to identify and remove unused objects
• Consolidation of similar objects to reduce redundancy
• Documentation of repository changes to maintain clarity

For large-scale projects, consider implementing a hybrid approach that combines local and shared repositories. This allows for better organization while maintaining flexibility for test-specific objects.

' Example of optimized object identification
' Using programmatic description for dynamic objects
Set desc = Description.Create()
desc("micclass").Value = "WebEdit"
desc("name").Value = "username"
desc("html tag").Value = "INPUT"

' Perform action using programmatic description
Browser("MyApp").Page("LoginPage").WebEdit(desc).Set "testuser"

' Using minimal object properties for static elements
Set loginButton = ObjectRepositoryUtil.GetObject("LoginButton", _
    "properties", "name:=LoginButton;html id:=btnLogin")
Browser("MyApp").Page("LoginPage").WebButton(loginButton).Click

Smart Identification Mechanism Explained

When UFT cannot identify an object using its stored properties, it activates the Smart Identification mechanism as a fallback. Understanding how this process works is crucial for troubleshooting and optimizing your tests.

Smart Identification uses a set of base filter properties and associated properties to identify objects. If the learned description fails, UFT attempts to identify the object using these additional properties. The process involves:

1. Creating a new list of objects based on the base filter properties

2. Filtering this list using associated properties

3. Selecting the object that best matches the description

Smart Identification works by first ignoring the learned test object description and then creating a new description based on the Smart Identification properties. UFT then filters objects matching this description and selects the one with the highest match level.

To configure Smart Identification, you define a set of properties that are likely to remain stable even if the object's appearance changes. These properties should be sufficiently unique to narrow down the object candidates but flexible enough to accommodate minor application changes.

' Configuring Smart Identification for a specific object class
Set objDesc = Description.Create()
objDesc("micclass").Value = "WebButton"
objDesc("html tag").Value = "INPUT"
objDesc("type").Value = "submit"

' Using Smart Identification when regular identification fails
Browser("MyApp").Page("Login").WebButton(objDesc).Click

While Smart Identification can help maintain tests when applications change, it should be used sparingly. Over-reliance on Smart Identification can mask underlying issues and make tests less stable. The best approach is to ensure that objects are uniquely identified using their primary properties, with Smart Identification serving as a safety net.

' Example of implementing Smart Identification
' Configure Smart Identification properties
Set smartID = ObjectRepositoryUtil.GetSmartIdentification("DynamicButton")
smartID.AddProperty "html id", "btnSubmit"
smartID.AddProperty "css class", "submit-button"
smartID.SetOrdinalIdentifier "index", 1

' Use Smart Identification when standard identification fails
On Error Resume Next
Set submitButton = ObjectRepositoryUtil.GetObject("SubmitButton")
If Err.Number <> 0 Then
    ' Fallback to Smart Identification
    Set submitButton = ObjectRepositoryUtil.GetObjectBySmartID("DynamicButton")
End If
On Error GoTo 0

' Perform action with the identified object
If Not submitButton Is Nothing Then
    Browser("MyApp").Page("FormPage").WebButton(submitButton).Click
Else
    Reporter.ReportEvent micFail, "Object Identification", "Could not identify submit button"
End If

Best Practices for Object Repository Maintenance

Maintaining a healthy Object Repository requires consistent practices and disciplined approaches. First, establish a naming convention that clearly identifies objects and their purpose. This makes navigation and understanding easier for all team members. Second, regularly audit your repositories to remove duplicates, outdated objects, and unnecessary properties. Third, implement a change management process for shared repositories to ensure modifications are properly reviewed and approved.

Another best practice is to use the Object Repository Comparison Tool to identify differences between repositories, helping maintain consistency across environments. Additionally, document your repository structure and decision-making processes to facilitate knowledge transfer and onboarding of new team members.

Repository maintenance best practices:

• Establish consistent naming conventions for objects
• Regularly audit repositories for duplicates and outdated entries
• Implement change management for shared repositories
• Use version control for repository files
• Document repository structure and changes

Consider implementing automation for repository maintenance tasks, such as property updates or object consolidation, to reduce manual effort and potential errors. This can be achieved through UFT's automation capabilities or by developing custom tools that interface with the Object Repository.

When implementing parameterization in your object repositories, ensure that the parameters are meaningful and well-documented. This approach allows for greater flexibility in your tests while maintaining clarity and maintainability.

Conclusion

Mastering object identification in UFT is essential for building robust, maintainable, and efficient automation frameworks. By understanding how the Object Repository works, implementing advanced management techniques, optimizing identification performance, leveraging Smart Identification appropriately, and following best practices for maintenance, you can significantly improve the reliability and longevity of your test automation.

The key to successful object repository management lies in finding the right balance between comprehensiveness and efficiency. While it's important to capture enough properties to ensure unique identification, storing too many properties can lead to performance issues and increased maintenance overhead. Regular audits and strategic organization of your repositories will help maintain this balance.

As applications continue to evolve, these advanced object repository management and optimization strategies will become increasingly critical for sustaining successful automation initiatives. Remember that effective object identification isn't just about making tests work—it's about making them maintainable, scalable, and resilient to change.

By implementing the techniques and best practices outlined in this guide, you can transform your object repositories from simple storage facilities into powerful, dynamic assets that enhance your testing capabilities and contribute to the overall success of your automation efforts.

Frequently Asked Questions

• What is object identification in UFT?
  Object identification in UFT refers to the mechanism by which the tool recognizes and interacts with elements within an application's user interface. It forms the critical bridge between test scripts and the application under test.
• What are the types of object repositories in UFT?
  UFT offers two main types of object repositories: local repositories embedded within individual test files, and shared repositories that can be used across multiple tests. Local repositories are ideal for small projects, while shared repositories offer better maintainability in large projects.
• How can I optimize object repositories in UFT?
  Optimization strategies include minimizing the number of properties stored for each object, using regular expressions for flexible matching, and implementing regular maintenance to remove unused objects and consolidate similar entries.
• What is Smart Identification in UFT?
  Smart Identification is a fallback mechanism in UFT that activates when the tool cannot identify an object using its stored properties. It uses a set of base filter properties and associated properties to identify objects when the learned description fails.
• What are best practices for object repository maintenance?
  Best practices include establishing consistent naming conventions, regularly auditing repositories for duplicates and outdated entries, implementing change management for shared repositories, using version control, and documenting repository structure and changes.