UFT Descriptive Programming: Inheritance & Modification

Mastering UFT Descriptive Programming: Inheritance and Modification Techniques for Advanced Automation

Descriptive Programming in UFT (Unified Functional Testing) provides a powerful approach to identify and interact with application objects without relying on the Object Repository, allowing testers to create more flexible and maintainable automation scripts. Programmatic description inheritance and modification techniques represent advanced methodologies that enable testers to build sophisticated object identification strategies that can adapt to dynamic application environments.

Understanding Descriptive Programming in UFT

Descriptive Programming is an alternative method to identify objects in the application under test (AUT) by directly describing their properties in the test script rather than using the Object Repository. This approach becomes particularly valuable when dealing with dynamically generated objects, complex object hierarchies, or applications where object properties change frequently across different environments. Unlike traditional object identification methods that depend on stored repository information, descriptive programming allows testers to define object properties at runtime, providing greater flexibility and control over test execution.

One of the primary advantages of descriptive programming is its ability to handle objects that are difficult to capture in the Object Repository, such as those with changing properties or those that appear only under specific conditions. This technique is especially useful when testing web applications with dynamic content, where element attributes might vary based on user interactions or system states. By implementing descriptive programming, testers can create more resilient automation frameworks that adapt to changes in the application without requiring constant updates to the Object Repository.

The syntax for descriptive programming typically involves creating a description object and then specifying the properties and values that uniquely identify the target object. This approach allows testers to be more precise in their object identification, reducing the chances of test failures due to object recognition issues.

' Basic descriptive programming example
Browser("Browser").Page("Page").WebElement("html tag:=div", "name:=username").Set "testuser"

The Basics of Programmatic Descriptions

Programmatic descriptions involve creating object properties dynamically within the test script using programming constructs. In UFT, this is typically achieved through the use of the Description object and the ChildObjects method, which allow testers to define object properties programmatically. The basic syntax involves creating a description object, setting its properties, and then using this description to identify objects in the application.

When implementing programmatic descriptions, testers can specify any combination of properties and values that uniquely identify an object. This includes standard properties like "name," "id," or "class" as well as custom properties that might be more specific to the application being tested. The flexibility of programmatic descriptions allows testers to create highly specific object identification strategies that can handle complex scenarios where traditional methods might fail.

Here's an example of basic descriptive programming syntax in UFT:

' Create a description object
Set objDesc = Description.Create()
' Set properties for the description
objDesc("micclass").Value = "WebButton"
objDesc("name").Value = "SubmitButton"
objDesc("html tag").Value = "INPUT"
' Use the description to identify the object
Set submitButton = Browser("Browser").Page("Page").ChildObjects(objDesc)

This code demonstrates how to create a programmatic description for a web button and use it to identify objects in the application. The approach provides greater flexibility than repository-based object identification, especially when dealing with objects that have dynamic properties.

Programmatic Description Inheritance Techniques

Programmatic description inheritance is a powerful technique that allows testers to create base descriptions that can be extended or modified for specific test scenarios. This approach promotes code reusability and reduces redundancy in test scripts. By defining common object properties in a base description, testers can create specialized descriptions that inherit these properties while adding unique identifiers for specific instances.

Inheritance techniques work by creating a parent description object that contains the common properties shared among multiple objects. Child descriptions can then inherit these properties and add or override specific properties as needed. This hierarchical approach makes test scripts more maintainable and easier to understand, as changes to common properties only need to be made in one place.

There are several methods to implement inheritance in UFT descriptive programming, including the use of child objects and description objects. The key is to identify the properties that remain constant across multiple objects and those that vary, then structure your descriptions accordingly to maximize reusability while maintaining specificity.

' Creating a base description with common properties
Set baseDesc = Description.Create
baseDesc("html tag").Value = "input"
baseDesc("class").Value = "form-control"

' Creating child descriptions that inherit from the base
Set usernameDesc = baseDesc.Clone
usernameDesc("name").Value = "username"

Set passwordDesc = baseDesc.Clone
passwordDesc("name").Value = "password"

' Using the inherited descriptions in test steps
Browser("Browser").Page("Page").WebElement(usernameDesc).Set "testuser"
Browser("Browser").Page("Page").WebElement(passwordDesc).Secure "testpass"

This example demonstrates how to create a base description with common properties and then create specialized descriptions that inherit these properties while adding unique identifiers. The inheritance pattern allows for the reuse of common properties while maintaining the flexibility to add or modify properties as needed.

Modification Strategies for Dynamic Objects

Dynamic objects in applications often change their properties based on various conditions such as user interactions, data loading, or system states. Modification strategies in descriptive programming enable testers to create flexible object identification approaches that can adapt to these changes. These strategies involve creating descriptions that can be modified at runtime based on specific conditions or parameters.

Dynamic property modification is one of the most powerful techniques in descriptive programming. This approach involves changing object properties during runtime based on conditions or values obtained from the application. For example, you might modify a description to include a dynamically generated ID or to adjust search criteria based on previously retrieved data. This flexibility allows tests to adapt to changing conditions while maintaining their reliability.

Another important modification technique is the use of regular expressions and wildcards in property values. These patterns can match multiple possible values, making tests more tolerant of minor changes in object properties. When combined with other descriptive properties, these patterns can create robust object identification strategies that work across different versions of an application or in various environments.

Key modification strategies include:

• Using regular expressions to match patterns in property values
• Implementing conditional logic to modify descriptions based on runtime conditions
• Creating parameterized descriptions that accept dynamic values
• Combining multiple properties with OR conditions to increase flexibility

Here's an example demonstrating a modification strategy for handling dynamic objects:

' Function to create a dynamic description based on input parameters
Function GetDynamicObjectDesc(objClass, propName, propValue, additionalProps)
    Set GetDynamicObjectDesc = Description.Create()
    GetDynamicObjectDesc("micclass").Value = objClass
    
    ' Check if we need to use regular expressions
    If InStr(propValue, "*") > 0 Or InStr(propValue, "?") > 0 Then
        GetDynamicObjectDesc(propName).RegularExpression = True
        GetDynamicObjectDesc(propName).Value = Replace(propValue, "*", ".*")
        GetDynamicObjectDesc(propName).Value = Replace(GetDynamicObjectDesc(propName).Value, "?", ".")
    Else
        GetDynamicObjectDesc(propName).Value = propValue
    End If
    
    ' Add any additional properties
    If Not IsEmpty(additionalProps) Then
        For Each prop In additionalProps
            GetDynamicObjectDesc(prop.name).Value = prop.value
        Next
    End If
End Function

' Usage example
Dim dynamicDesc
Set dynamicDesc = GetDynamicObjectDesc("WebEdit", "name", "username_*", Array( _
    Array("name", "type"), Array("value", "text") _
))

Set usernameField = Browser("Browser").Page("Page").ChildObjects(dynamicDesc)

This example demonstrates how to create a dynamic description that can handle objects with varying property values using regular expressions. The function accepts parameters for the object class, property name and value, and additional properties, allowing for flexible object identification based on runtime conditions.

Here's another example showing dynamic modification of descriptive programming:

' First, get a dynamic value from the application
dynamicValue = Browser("Browser").Page("Page").WebElement("id:=dynamicElement").GetROProperty("value")

' Create a modified description based on the dynamic value
Set modifiedDesc = Description.Create
modifiedDesc("html tag").Value = "div"
modifiedDesc("innertext").Value = ".*" & dynamicValue & ".*"

' Use the modified description to find related elements
relatedElements = Browser("Browser").Page("Page").ChildObjects(modifiedDesc)

Advanced Implementation Patterns

Advanced implementation patterns in descriptive programming involve sophisticated techniques for organizing and managing object descriptions in complex test automation frameworks. These patterns go beyond basic descriptive programming to provide scalable and maintainable solutions for large-scale testing projects. Some of the most effective patterns include description repositories, factory patterns for creating descriptions, and hybrid approaches that combine descriptive programming with other object identification methods.

Description repositories involve centralizing object descriptions in external files or databases, allowing for easier maintenance and reuse across multiple test scripts. Factory patterns provide structured ways to create and manage description objects, ensuring consistency and reducing code duplication. Hybrid approaches leverage the strengths of both descriptive programming and repository-based methods, using each where it provides the most benefit.

These advanced patterns enable teams to build more sophisticated automation frameworks that can handle complex applications with varying object structures and properties. By implementing these patterns, testers can create more maintainable and scalable automation solutions that require less maintenance effort and provide greater flexibility in handling dynamic application environments.

Here's an example of a factory pattern implementation for creating descriptions:

' Description Factory class
Class DescriptionFactory
    Private descriptions
    
    Private Sub Class_Initialize()
        Set descriptions = CreateObject("Scripting.Dictionary")
    End Sub
    
    Public Function GetDescription(descriptionName)
        If Not descriptions.Exists(descriptionName) Then
            ' Load or create the description based on the name
            Select Case descriptionName
                Case "submitButton"
                    Set GetDescription = CreateSubmitButtonDesc()
                Case "usernameField"
                    Set GetDescription = CreateUsernameFieldDesc()
                Case "menuOption"
                    Set GetDescription = CreateMenuOptionDesc()
                Case Else
                    Set GetDescription = Nothing
            End Select
            
            ' Store the description for future use
            If Not GetDescription Is Nothing Then
                descriptions.Add descriptionName, GetDescription
            End If
        Else
            Set GetDescription = descriptions(descriptionName)
        End If
    End Function
    
    Private Function CreateSubmitButtonDesc()
        Set CreateSubmitButtonDesc = Description.Create()
        CreateSubmitButtonDesc("micclass").Value = "WebButton"
        CreateSubmitButtonDesc("name").Value = "Submit"
        CreateSubmitButtonDesc("type").Value = "submit"
    End Function
    
    Private Function CreateUsernameFieldDesc()
        Set CreateUsernameFieldDesc = Description.Create()
        CreateUsernameFieldDesc("micclass").Value = "WebEdit"
        CreateUsernameFieldDesc("name").RegularExpression = True
        CreateUsernameFieldDesc("name").Value = "username.*"
    End Function
    
    Private Function CreateMenuOptionDesc()
        Set CreateMenuOptionDesc = Description.Create()
        CreateMenuOptionDesc("micclass").Value = "Link"
        CreateMenuOptionDesc("tag").Value = "A"
    End Function
End Class

' Usage example
Dim descFactory
Set descFactory = New DescriptionFactory

Set submitButton = Browser("Browser").Page("Page").ChildObjects(descFactory.GetDescription("submitButton"))
Set usernameField = Browser("Browser").Page("Page").ChildObjects(descFactory.GetDescription("usernameField"))

This example demonstrates a factory pattern for creating and managing descriptions. The factory class maintains a collection of descriptions and provides methods to retrieve them by name. This approach centralizes description management and ensures consistency across the test automation framework.

Best Practices and Optimization Tips

Implementing descriptive programming effectively requires adherence to certain best practices that ensure the creation of maintainable and efficient test scripts. One key best practice is to use the most specific and stable properties possible for object identification, reducing the likelihood of false positives and minimizing the impact of changes in the application. Another important practice is to modularize descriptions by creating reusable functions or classes that generate descriptions, reducing code duplication and improving maintainability.

Optimization tips include minimizing the number of properties used in descriptions to improve performance, using regular expressions judiciously to avoid unnecessary complexity, and implementing proper error handling for cases where objects cannot be found. Additionally, combining descriptive programming with other object identification methods, such as ordinal identifiers or index properties, can provide more robust object identification in complex scenarios.

When implementing descriptive programming, it's also important to document descriptions thoroughly and establish naming conventions that make the code more readable and maintainable. Regular reviews and refactoring of descriptive programming code can help identify opportunities for improvement and ensure that the automation framework remains efficient and scalable as the application evolves.

Conclusion

UFT Descriptive Programming, particularly when combined with inheritance and modification techniques, provides a powerful approach to creating flexible and maintainable test automation frameworks. By understanding and implementing these advanced techniques, testers can build automation solutions that can adapt to dynamic application environments, reduce maintenance overhead, and improve the reliability of test execution. The strategic application of descriptive programming inheritance and modification techniques enables teams to create sophisticated automation frameworks that can handle complex testing scenarios with greater efficiency and effectiveness.

Frequently Asked Questions

• What is UFT Descriptive Programming?
  UFT Descriptive Programming is a method to identify objects in applications by directly describing their properties in test scripts rather than using the Object Repository, providing greater flexibility for automation.
• How does programmatic description inheritance work?
  Programmatic description inheritance allows testers to create base descriptions with common properties that can be extended or modified for specific scenarios, promoting code reusability and reducing redundancy.
• What are modification strategies for dynamic objects?
  Modification strategies involve creating descriptions that can be changed at runtime based on conditions, using regular expressions, implementing conditional logic, and combining properties with OR conditions.
• What are best practices for implementing descriptive programming?
  Use specific and stable properties for identification, modularize descriptions, minimize properties used, implement proper error handling, and document descriptions thoroughly.
• How can descriptive programming improve test automation?
  Descriptive programming creates more flexible and maintainable automation scripts that can adapt to dynamic application environments, reducing maintenance overhead and improving test reliability.