UFT Distributed Setup: Network Configuration Guide

Installing and Setting Up UFT - Network Configuration for Distributed UFT Execution

Unified Functional Testing (UFT) is a powerful testing solution that enables organizations to automate their testing processes across various applications and platforms. When configured for distributed execution across your network, UFT can significantly enhance your testing capabilities, allowing you to leverage multiple resources, accelerate test runs, and create a more efficient testing environment that doesn't block user machines. One of the most valuable features of UFT is its ability to execute tests in a distributed manner, allowing teams to run multiple tests simultaneously across different machines in a network. This capability dramatically reduces execution time and maximizes the utilization of available resources. However, setting up distributed UFT execution requires careful network configuration to ensure seamless communication between the controller and agent machines.

Understanding Distributed UFT Execution

Unified Functional Testing, developed by Micro Focus, provides a comprehensive solution for functional and regression testing across applications. Distributed UFT execution is a methodology that allows test scripts to be run across multiple machines in a network environment. In this setup, one machine acts as the controller, responsible for distributing test scripts to multiple agent machines that execute them concurrently. This approach is particularly beneficial for organizations with large test suites that would take an impractical amount of time to run sequentially.

The distributed execution model consists of several key components: the controller machine that orchestrates test execution, the agent or host machines that actually run the tests, and the network infrastructure that facilitates communication between these components. Understanding these elements and their interdependencies is crucial for a successful implementation.

The distributed execution model offers several advantages:

• Reduced test execution time
• Better utilization of available hardware resources
• Ability to run tests in parallel across different environments
• Scalability to accommodate growing testing needs

When implementing distributed UFT execution, it's essential to understand the roles of each component in the architecture. The controller machine is typically where the test execution is initiated and results are collected. Agent machines, on the other hand, are responsible for executing the assigned tests and communicating their status back to the controller. This division of labor requires a robust network infrastructure to ensure reliable communication and data transfer between components.

The distributed execution model can be implemented in various configurations depending on organizational needs. It can range from a simple setup with one controller and two agents to complex networks with multiple controllers and hundreds of agents. Regardless of the scale, proper network configuration remains critical to the success of the implementation.

Distributed UFT execution works by distributing test components across available computing resources, including physical machines, virtual machines, or cloud-based resources. The central controller manages the distribution, ensuring that tests run in parallel while maintaining synchronization and result collection. This architecture not only speeds up test execution but also optimizes resource utilization by allowing you to leverage existing infrastructure without dedicating specific machines solely for testing purposes.

Prerequisites for Distributed UFT Setup

Before embarking on the installation and configuration of distributed UFT execution, it's crucial to ensure that all prerequisites are met. This preparation phase helps prevent installation issues and ensures a smooth setup process.

System Requirements

The controller machine requires a robust configuration to handle the coordination of multiple test executions simultaneously. This machine should have a multi-core processor, at least 16GB of RAM, and sufficient disk space to store test assets and results. The operating system must be compatible with the UFT version you're implementing, typically Windows Server or a supported Windows client OS. Network bandwidth is another critical consideration, as insufficient bandwidth can create bottlenecks when transferring test data between the controller and agent machines.

For agent machines, the requirements are slightly less demanding but still important. Each agent should have a multi-core processor, at least 8GB of RAM, and adequate storage for test execution logs. These machines must also run a compatible operating system and have the UFT execution components installed. Network connectivity between the controller and agents must be reliable, with minimal latency to ensure synchronized test execution.

Network Requirements

Network requirements are particularly important for distributed execution. All machines must be connected to the same network with proper communication protocols enabled. Ensure that:

• Network ports required for UFT communication are open (typically 50900-50999 for the execution engine and 8080 for the web controller)
• Firewall settings allow communication between controller and agent machines
• Network latency is minimized to prevent communication delays
• DNS resolution works correctly between all machines in the distributed environment
• Static IP addresses are used for all machines to prevent address changes that could disrupt communication

Software Prerequisites

Software prerequisites include having UFT installed on both controller and agent machines, along with any necessary add-ins or plugins required for the applications being tested. Additionally, consider the following preparation steps:

• Create dedicated user accounts with appropriate permissions on all machines
• Ensure consistent time synchronization across all machines
• Prepare test scripts and test data for distribution
• Document the network topology and IP addresses for reference
• Verify that all machines are running the same version of UFT to avoid compatibility issues

Taking the time to thoroughly prepare for distributed UFT execution setup can save significant troubleshooting efforts later and ensure a more stable and reliable testing environment.

Step-by-Step Installation Guide

The installation process for setting up distributed UFT execution involves several key steps that must be performed in sequence. Following these methodically will help establish a solid foundation for your distributed testing environment.

Begin with installing UFT on the controller machine. This machine will serve as the central point for test execution management. The installation process typically involves:

• Running the UFT installation package
• Accepting the license agreement
• Selecting the installation location
• Choosing components to install (core UFT functionality, add-ins, etc.)
• Configuring installation settings according to your requirements

During installation, you'll need to select the appropriate components for distributed testing, including the controller functionality and any required add-ins for your application under test. The installation wizard will guide you through these selections, ensuring all necessary components are included.

Once UFT is installed on the controller machine, proceed with installing UFT on each agent machine. The agent installation is similar but with a few differences:

• Select "Agent" installation type instead of "Full" or "Standard"
• Ensure the same version of UFT is installed on all machines
• Verify that all necessary add-ins are included in the agent installations

For agent machines, the installation process focuses on the execution components rather than the controller functionality. Each agent machine must be installed with the same version of UFT as the controller to maintain compatibility. During installation, ensure that the execution components are properly configured to communicate with the controller on your network.

After installing UFT on all machines, the next step is to configure the controller to recognize and communicate with the agent machines. This involves:

• Opening UFT on the controller machine
• Navigating to the Tools > Options menu
• Selecting the "Distributed Execution" tab
• Adding agent machine names or IP addresses to the agent list
• Specifying the port numbers for communication
• Testing the connection to each agent machine

Finally, verify that the distributed execution environment is functioning correctly by running a simple test across multiple agents. This validation step helps identify any configuration issues before deploying the environment for production testing use.

It's worth noting that the installation process may vary slightly depending on the specific version of UFT being deployed. Always refer to the official installation documentation for version-specific instructions and requirements.

Network Configuration Essentials

Proper network configuration is the cornerstone of successful distributed UFT execution. Without a well-configured network, communication between controller and agent machines may fail, leading to test execution failures and unreliable results.

The first aspect of network configuration involves ensuring that all machines can communicate with each other. This requires:

• Verifying that all machines are on the same subnet or can route to each other
• Checking that IP addresses and DNS entries are correctly configured
• Ensuring that network switches and routers are functioning properly
• Testing basic connectivity using tools like ping or telnet

Port configuration is particularly critical, as it must allow communication on specific ports while maintaining security. UFT uses several ports for communication between controller and agents, typically including ports 50900-50999 for the execution engine and port 8080 for the web controller. You'll need to configure your firewalls to allow traffic on these ports between all participating machines.

Here's a PowerShell script to help verify network connectivity between controller and agent machines:

# Test-ControllerAgentConnectivity.ps1
# Script to verify network connectivity between UFT controller and agent machines

$controllerIP = "192.168.1.100" # Replace with your controller IP
$agentIPs = @("192.168.1.101", "192.168.1.102", "192.168.1.103") # Replace with your agent IPs

Write-Host "Testing connectivity between controller and agent machines..."
Write-Host "Controller IP: $controllerIP"

foreach ($agentIP in $agentIPs) {
    $pingResult = Test-Connection -ComputerName $agentIP -Count 2 -ErrorAction SilentlyContinue
    
    if ($pingResult) {
        Write-Host "Connection to agent $agentIP successful - Latency: $($pingResult.ResponseTime)ms"
    } else {
        Write-Host "Connection to agent $agentIP failed - Check network configuration"
    }
}

And here's a sample batch script to configure firewall rules for UFT distributed execution:

@echo off
REM Configure-UFTFirewall.bat
REM Script to configure firewall rules for UFT distributed execution

setlocal

echo Configuring firewall rules for UFT distributed execution...

REM Allow UFT execution engine ports (50900-50999)
for /L %%i in (50900,1,50999) do (
    netsh advfirewall firewall add rule name="UFT_Execution_Engine_%%i" dir=in action=allow protocol=TCP localport=%%i
)

REM Allow UFT web controller port (8080)
netsh advfirewall firewall add rule name="UFT_Web_Controller_8080" dir=in action=allow protocol=TCP localport=8080

echo Firewall configuration complete.
pause

Network security should be balanced with functionality. Implementing proper authentication mechanisms ensures that only authorized machines can participate in your distributed testing environment. This might involve configuring Windows authentication or implementing additional security protocols depending on your organization's requirements.

Setting Up Automation Object Service (AOS)

The Automation Object Service (AOS) is a critical component for distributed UFT execution, serving as the communication backbone between the controller and agent machines. Proper setup of AOS ensures seamless test execution across your distributed environment.

To begin, install the AOS on the designated controller machine. This service handles the distribution of test components to agent machines and coordinates their execution. During installation, you'll need to specify the service account that will run the AOS, which should have appropriate permissions on both the controller and agent machines.

After installation, configure the AOS service settings to match your distributed environment requirements. This includes specifying the port range for communication, setting timeout values, and configuring authentication mechanisms. The AOS configuration should align with your network topology and security policies to ensure reliable operation.

For agent machines, you'll need to install the AOS client components and configure them to connect to the central AOS service. This involves specifying the controller's IP address or hostname and ensuring that the network path is accessible from each agent machine. Connection testing utilities are available to verify this configuration before executing tests.

Here's a sample XML configuration file for the AOS service:

<?xml version="1.0" encoding="UTF-8"?>
<AOSConfiguration>
  <Service>
    <Name>UFTAutomationObjectService</Name>
    <PortRange>50900-50999</PortRange>
    <Timeout>300</Timeout>
    <MaxConnections>100</MaxConnections>
  </Service>
  <Security>
    <AuthenticationMode>Windows</AuthenticationMode>
    <AllowedMachines>
      <Machine>192.168.1.101</Machine>
      <Machine>192.168.1.102</Machine>
      <Machine>192.168.1.103</Machine>
    </AllowedMachines>
  </Security>
  <Logging>
    <Enabled>true</Enabled>
    <Level>Info</Level>
    <Path>C:\Program Files\UFT\AOSLogs</Path>
  </Logging>
</AOSConfiguration>

Best Practices for Distributed UFT Execution

Implementing distributed UFT execution requires attention to several best practices to ensure optimal performance, reliability, and maintainability of your testing infrastructure. These practices span configuration, execution, and maintenance aspects of your distributed testing environment.

One key best practice is to maintain consistency across all machines in your distributed environment. This includes using the same UFT version, patch levels, and configuration settings on both controller and agent machines. Consistency minimizes compatibility issues and ensures that tests execute reliably across all resources.

Resource management is another critical consideration. Implement mechanisms to monitor and optimize the distribution of tests across available resources. This might involve setting up priority queues for different test types or implementing load balancing algorithms to distribute test execution evenly across agent machines.

Regular maintenance and monitoring of your distributed UFT environment will ensure long-term reliability. This includes periodic review of network performance, updating components as new versions become available, and documenting any changes to the configuration. Monitoring tools can help identify bottlenecks or failures before they impact test execution.

When configuring your distributed UFT execution environment, consider these best practices:

• Use consistent configurations across all machines
• Implement proper authentication and security measures
• Regularly update and maintain components
• Monitor network performance and resource utilization
• Document configurations and changes for future reference

Conclusion

Proper network configuration for distributed UFT execution is essential for maximizing the efficiency and reliability of your automated testing environment. By following the installation and setup procedures outlined in this guide, you can create a robust distributed testing infrastructure that leverages multiple resources to accelerate test execution while maintaining synchronization and result integrity. The benefits of a well-configured distributed UFT environment extend beyond simply reducing test execution time—they include better resource utilization, improved scalability, and enhanced flexibility in your testing approach. As your testing needs evolve, a properly configured distributed UFT execution environment will provide the foundation to scale your automation efforts efficiently and effectively.

Frequently Asked Questions

• What is distributed UFT execution?
  Distributed UFT execution is a methodology that allows test scripts to be run across multiple machines in a network environment, with one machine acting as the controller and others as agents executing tests concurrently.
• What are the system requirements for distributed UFT setup?
  The controller machine requires a multi-core processor, at least 16GB RAM, and sufficient disk space. Agent machines need a multi-core processor, at least 8GB RAM, and adequate storage for test execution logs.
• Which network ports need to be configured for UFT distributed execution?
  UFT typically uses ports 50900-50999 for the execution engine and port 8080 for the web controller. These ports must be open in firewall settings to allow communication between controller and agent machines.
• How do I verify connectivity between controller and agent machines?
  You can use PowerShell scripts to test connectivity between machines, checking for proper network configuration, firewall settings, and DNS resolution. The provided script in the article demonstrates this process.
• What is the Automation Object Service (AOS) in UFT distributed execution?
  AOS serves as the communication backbone between controller and agent machines, handling distribution of test components and coordinating their execution. It must be properly configured on both controller and agent machines.