UFT Installation & Plugin Development Guide (PART-2)

Installing and Setting Up UFT - A Comprehensive Guide to UFT Plugin Architecture and Custom Plugin Development

Unified Functional Testing (UFT) is a powerful automated testing solution that enables organizations to test their applications across various platforms and technologies. The true power of UFT lies in its extensibility through its robust plugin architecture, which allows testers to develop custom plugins to support unique applications and testing scenarios. This guide will walk you through the complete process of installing and setting up UFT, followed by an in-depth exploration of its plugin architecture and the development of custom plugins to extend its capabilities.

Understanding UFT and Its Plugin Architecture

Unified Functional Testing is a comprehensive testing solution that supports functional and regression testing across various applications, web, mobile, and API testing. At the heart of UFT's flexibility lies its plugin architecture, which allows the tool to adapt to different technologies and environments. This modular design enables UFT to recognize and interact with diverse application components efficiently.

The plugin architecture works through add-ins that provide specialized support for specific technologies. When you install UFT, it comes with several built-in add-ins for common technologies like Web, Windows, Java, and .NET. Each add-in extends UFT's capabilities by providing:

• Specialized object repositories
• Custom methods and properties
• Technology-specific recording and playback mechanisms
• Unique identification mechanisms for objects

This architecture ensures that UFT can handle virtually any application type while maintaining consistent testing workflows across different technologies. By understanding this architecture, testers can better configure UFT for their specific needs and identify opportunities for custom development when built-in add-ins fall short.

The beauty of this architecture lies in its modularity—you can add or remove support for different technologies as needed, allowing UFT to remain lightweight and focused on the technologies you're actually testing. This approach not only optimizes performance but also simplifies maintenance and updates.

Installing UFT - Step-by-Step Guide

The installation process for UFT is straightforward but requires careful attention to detail to ensure a successful setup. Before beginning, verify that your system meets the minimum requirements, including compatible operating system, sufficient RAM, and available disk space. The installation can be performed from a DVD or downloaded installation package, with options for full installation or custom selection of components.

To begin the installation:

1. Run the installation executable and accept the license agreement

2. Choose installation type (Typical, Compact, or Custom)

3. Select the desired add-ins based on your testing requirements

4. Configure installation location and additional options

5. Complete the installation and verify successful launch

For organizations implementing UFT across multiple machines, consider creating a deployment package using the installation customization tools. This ensures consistent configurations across your testing environment. After installation, it's crucial to install any necessary expansion packs or additional components that may be required for your specific testing scenarios.

When selecting add-ins during installation, be strategic about your choices. Including add-ins for technologies you don't test will unnecessarily consume system resources and may impact performance. Conversely, omitting necessary add-ins will limit UFT's ability to recognize and interact with your applications. The Custom installation option allows you to precisely select only the add-ins you need, optimizing both installation time and system resources.

Overview of UFT Plugins and Their Functionality

UFT plugins, also known as add-ins, are specialized components that extend the tool's capabilities to support specific technologies and applications. These plugins are essential for enabling UFT to recognize and interact with application objects accurately. Each plugin is designed to understand the unique characteristics and behaviors of objects within its supported technology.

The standard UFT installation includes several key plugins:

• Web: For testing web applications across different browsers
• Windows: For testing standard Windows applications
• Java: For testing Java-based applications
• .NET: For testing .NET framework applications
• SAP: For testing SAP applications
• Mobile: For testing mobile applications on iOS and Android platforms

Additionally, UFT supports various specialized plugins for technologies like Oracle, PeopleSoft, and Siebel. These plugins provide enhanced object recognition methods and specialized test objects that align with the unique structures of these applications. When working with applications that use custom controls or emerging technologies, understanding how plugins work becomes crucial for identifying whether you need to develop a custom plugin or extend an existing one.

Each plugin contains three essential components:

1. Object Recognition Mechanisms: These define how UFT identifies and maps objects in your application. This includes the properties used to uniquely identify objects and the hierarchy in which they're recognized.

2. Test Object Model: This defines the structure and properties of test objects that UFT creates when you record tests. The test object model abstracts the application objects into a format that UFT can understand and manipulate.

3. Operation Methods: These define the actions that can be performed on the test objects, such as click, type, select, and custom methods specific to the technology.

Understanding these components helps in troubleshooting issues with object recognition and in developing effective custom plugins when needed.

Developing Custom Plugins for UFT

When the built-in add-ins don't sufficiently support your application's unique controls or technologies, developing custom plugins becomes necessary. Custom plugin development allows you to create specialized add-ins that provide enhanced object recognition and interaction capabilities for your specific applications. This process involves several technical steps and requires programming knowledge, typically in C# or VB.NET.

To begin developing a custom plugin:

1. Set up the development environment with Visual Studio and the UFT SDK

2. Create a new Class Library project for your plugin

3. Implement the required interfaces and base classes from the UFT extensibility framework

4. Develop custom test objects, methods, and properties

5. Implement object identification mechanisms

Here's a basic example of a custom test class implementation:

using Mercury.QTP.PluginUtil;
using Mercury.QTP.TestObjects;

namespace CustomPlugin
{
    public class CustomTestObject : TestObject
    {
        public CustomTestObject()
        {
            this._init();
        }
        
        private void _init()
        {
            this.RegisterMethods("CustomPlugin");
            this.RegisterProperties("CustomPlugin");
            this.RegisterIdentifications("CustomPlugin");
        }
        
        public override string GetTOProperty(string propertyName)
        {
            // Custom property retrieval logic
            return base.GetTOProperty(propertyName);
        }
    }
}

When developing custom plugins, it's important to thoroughly test the object recognition mechanisms and interaction methods to ensure reliability. Custom plugins significantly enhance UFT's ability to test applications with proprietary or custom controls that aren't supported out of the box.

The development process typically involves creating a test object class that inherits from UFT's base TestObject class, implementing identification methods that define how your objects are recognized, and registering custom properties and methods that extend UFT's functionality for your specific technology.

Testing and Deploying Custom Plugins

Once you've developed a custom plugin, rigorous testing is essential to ensure it functions correctly within the UFT environment. The testing process should validate both the object recognition capabilities and the interaction methods implemented in your plugin. Begin by creating test cases that cover various scenarios, including edge cases and error conditions.

To test your custom plugin:

1. Register the plugin with UFT using the Add-in Manager

2. Create a simple test that uses objects recognized by your plugin

3. Verify object identification in the Object Repository

4. Test all custom methods and properties

5. Check for proper integration with UFT's features like checkpoints and reporting

Common issues encountered during testing include:

• Objects not being recognized correctly
• Methods failing to execute properly
• Properties returning incorrect values
• Integration problems with UFT's built-in features

Once testing is complete and the plugin is stable, deploy it to your testing environments. This typically involves copying the plugin assembly to the appropriate UFT installation directory and registering it with the Add-in Manager. For enterprise deployments, consider creating an installation package that handles the registration process automatically.

During the testing phase, it's crucial to validate not only that your plugin works in isolation but also that it integrates seamlessly with UFT's existing features. This includes ensuring that checkpoints function correctly, reporting captures all relevant information, and the Object Repository properly stores and retrieves your custom objects.

Advanced Plugin Development Techniques

For complex applications or specialized testing requirements, advanced plugin development techniques can significantly enhance UFT's capabilities. These techniques include implementing sophisticated object recognition algorithms, creating custom test object models, and integrating with external testing frameworks or tools.

One advanced technique involves implementing custom identification mechanisms that go beyond the standard properties used by UFT. This is particularly useful for applications with dynamic or complex object structures. Here's an example of a custom identification mechanism:

public class CustomIdentification : Identification
{
    public override bool CanIdentify(object obj, ITestObject testObject)
    {
        // Custom logic to determine if this identification method applies
        return true;
    }
    
    public override string GetDescription(object obj, ITestObject testObject)
    {
        // Return a description of the identified object
        return "Custom identification method";
    }
    
    public override string GetImplementation(object obj, ITestObject testObject)
    {
        // Return the implementation details
        return "Custom implementation";
    }
}

Another advanced technique involves extending UFT's functionality by integrating with external APIs or services. This allows you to leverage additional testing capabilities or integrate with your existing development and testing infrastructure. For example, you could create a plugin that integrates with your CI/CD pipeline to trigger UFT tests as part of the build process.

For applications with complex UI structures, implementing a hierarchical object recognition model can significantly improve reliability. This approach involves teaching UFT to recognize objects not just by their properties but also by their relationship to other objects in the UI hierarchy. This is particularly useful for applications that dynamically generate UI elements or use complex frameworks.

Conclusion

Mastering the installation, configuration, and customization of UFT through its plugin architecture is essential for maximizing the tool's potential in your testing environment. By understanding how UFT's modular design works, you can effectively select and configure the appropriate add-ins for your applications. When built-in add-ins fall short, developing custom plugins provides a powerful way to extend UFT's capabilities to handle even the most specialized testing scenarios.

Investing time in learning about UFT plugin architecture and custom development not only improves your testing efficiency but also empowers you to tackle complex testing challenges with confidence. As applications continue to evolve and become more sophisticated, the ability to customize and extend your testing tools will remain a critical skill for quality assurance professionals.

By following the guidance in this comprehensive guide, you'll be well-equipped to install, configure, and extend UFT to meet your specific testing requirements, whether you're working with standard applications or complex, proprietary systems that demand custom solutions.

Frequently Asked Questions

• What is UFT plugin architecture?
  UFT plugin architecture is a modular design that allows the tool to adapt to different technologies through add-ins, providing specialized object repositories, custom methods, and technology-specific recording mechanisms.
• How do I install UFT with custom add-ins?
  During installation, choose the Custom option to selectively install only the add-ins you need, optimizing both installation time and system resources for your specific testing requirements.
• When should I develop a custom UFT plugin?
  You should develop a custom plugin when built-in add-ins don't sufficiently support your application's unique controls or technologies, requiring enhanced object recognition and interaction capabilities.
• What are the essential components of a UFT plugin?
  Essential components include object recognition mechanisms that define how UFT identifies objects, a test object model that structures application objects, and operation methods that define actions performed on test objects.
• How do I test and deploy custom UFT plugins?
  Test custom plugins by registering them with UFT, creating test cases for various scenarios, verifying object identification, and testing all custom methods before deploying to testing environments.