UFT Parameterization: Advanced Data Table Techniques

Parameterization in UFT - Advanced Data Table Manipulation and External Connections

Parameterization in UFT (Unified Functional Testing) is a powerful technique that transforms static tests into dynamic, data-driven automation scripts. By replacing fixed values with variables that can be sourced from multiple locations, testers can create more robust, maintainable, and flexible test scenarios that closely mimic real-world application usage.

Understanding Parameterization in UFT

Parameterization in UFT refers to the process of replacing hardcoded values in test scripts with variables that can take on different values during test execution. This fundamental concept allows testers to run the same test with multiple sets of data, significantly increasing test coverage and efficiency. The primary goal of parameterization is to make tests more adaptable to changing requirements and data scenarios.

The key advantage of parameterization is the ability to separate test data from test logic, making tests more maintainable and adaptable to changing requirements. When implemented correctly, parameterization can reduce test maintenance effort by up to 60% while expanding test coverage exponentially. This separation allows testers to focus on test logic while data can be modified without touching the underlying code.

Types of Parameterization in UFT

UFT offers several parameterization methods to suit different testing requirements. Understanding these types is crucial for selecting the most appropriate approach for specific testing scenarios.

Data table parameters represent the most commonly used parameterization method, allowing values to be sourced directly from the test's data table. This approach is ideal for data-driven testing where multiple iterations with different data sets are required.

Environment variables provide another parameterization option, enabling values to be sourced from external files or system variables. This method is particularly useful for configuration data that remains consistent across tests.

Random number parameters generate random values within specified ranges, which is valuable for testing applications with unique identifiers or for load testing scenarios.

Test/action parameters facilitate communication between different test components, allowing data to be passed between tests, actions, or components.

The choice of parameterization method depends on factors such as data source requirements, test complexity, and maintenance considerations. Experienced testers often combine multiple parameterization techniques to create comprehensive testing solutions.

' Example of Data Table Parameterization
' This code demonstrates how to use the data table for parameterization
Browser("Browser").Page("Page").WebEdit("username").Set DataTable("Username", dtLocalSheet)
Browser("Browser").Page("Page").WebEdit("password").Set DataTable("Password", dtLocalSheet)
Browser("Browser").Page("Page").WebButton("Login").Click

Data Table Parameterization Fundamentals

The Data Table is the cornerstone of parameterization in UFT. It appears as a spreadsheet-like interface within the UFT IDE, organized into three default sheets: Global, Action1 (and subsequent action sheets), and Local. Each sheet serves a specific purpose in storing and managing test data.

To create a Data Table parameter, follow these basic steps:

1. Identify the value in your test script that you want to parameterize

2. Right-click on the value and select "Parameterize"

3. Choose the parameter type (usually Data Table)

4. Select the appropriate sheet and column for the parameter

5. Enter the test data values in the Data Table

The Global sheet is accessible across all actions in a test, making it ideal for data that needs to be shared. Action sheets are specific to individual actions, while Local sheets are temporary and cleared after each test run. Understanding these distinctions is crucial for effective data management.

When parameterizing, UFT automatically replaces the fixed value with a syntax that references the Data Table, such as DataTable("ParameterName", dtGlobalSheet). This reference tells UFT where to find the value during test execution, allowing for seamless data-driven testing.

Advanced Data Table Manipulation Techniques

Moving beyond basic parameterization, advanced Data Table manipulation techniques enable testers to handle complex testing scenarios with ease. These techniques include working with multiple data sheets, utilizing formulas within the Data Table, and managing data iteration and synchronization.

One powerful technique is the use of multiple Data Tables within a single test. This allows for better organization of different types of test data and makes it easier to maintain large test suites. For example, you might separate test data for login credentials from product data, making each dataset more manageable.

Data tables in UFT can be manipulated programmatically using VBScript, allowing for dynamic data generation, filtering, and transformation during test execution. This capability is particularly valuable when dealing with large datasets or when test data needs to be generated based on specific business rules.

Conditional data insertion enables testers to add rows to the data table based on certain conditions, providing flexibility for scenario testing. This technique can be used to implement positive and negative test cases dynamically within the same test script.

' Example of Advanced Data Table Manipulation
' This code demonstrates how to dynamically add rows to the data table
If DataTable("Status", dtLocalSheet) = "Pass" Then
    DataTable.AddSheet "PassCases"
    DataTable.SetCurrentRow 1
    DataTable("Username", "PassCases") = "testuser"
    DataTable("Password", "PassCases") = "securepass"
End If

Formulas in the Data Table can significantly enhance test capabilities:

• Concatenation: Combining values from different columns
• Date calculations: Generating future or past dates for testing
• Conditional logic: Using IF statements to determine values based on criteria
• Mathematical operations: Performing calculations on numeric data

Here's an example of how you might use formulas in the Data Table to generate test dates:

' Example of using Data Table formulas in UFT
' This code generates future dates for testing expiration scenarios

Function GetFutureDate(daysToAdd)
    currentDate = Date
    futureDate = DateAdd("d", daysToAdd, currentDate)
    GetFutureDate = Format(futureDate, "mm/dd/yyyy")
End Function

' Usage in test script
expirationDate = GetFutureDate(30)
DataTable("ExpirationDate", dtGlobalSheet) = expirationDate

Data iteration and synchronization are also crucial for advanced testing. UFT allows you to control how tests iterate through the Data Table, whether row by row or based on specific conditions. This flexibility enables testers to create sophisticated test scenarios that adapt to different data conditions and requirements.

External Data Connections in UFT

For enterprise-level testing, the ability to connect to external data sources is essential. UFT provides robust capabilities for connecting to various external databases, file formats, and data repositories, allowing testers to leverage existing data infrastructure and maintain centralized data management.

Connecting to external databases is a common requirement in modern testing environments. UFT supports connections to:

• SQL Server databases
• Oracle databases
• MySQL databases
• ODBC-compliant databases

The process typically involves establishing a connection string, executing queries, and then processing the results. Here's an example of how to connect to a SQL database in UFT:

' Example of connecting to an external SQL database in UFT

Dim connection, recordset, connectionString, query

' Set up connection string
connectionString = "Provider=SQLOLEDB;Data Source=ServerName;Initial Catalog=DatabaseName;User ID=Username;Password=Password;"

' Create connection and recordset objects
Set connection = CreateObject("ADODB.Connection")
Set recordset = CreateObject("ADODB.Recordset")

' Open connection
connection.Open connectionString

' Define SQL query
query = "SELECT username, password FROM users WHERE status = 'active'"

' Execute query and open recordset
recordset.Open query, connection

' Process results
Do Until recordset.EOF
    DataTable("Username", dtGlobalSheet) = recordset("username")
    DataTable("Password", dtGlobalSheet) = recordset("password")
    ' Run test with these credentials
    RunTest
    recordset.MoveNext
Loop

' Clean up
recordset.Close
connection.Close
Set recordset = Nothing
Set connection = Nothing

Beyond databases, UFT can read from and write to various file formats, including:

• Excel spreadsheets
• CSV files
• Text files
• XML files
• JSON files

These connections enable testers to integrate with existing data management systems, maintain data in familiar formats, and separate test data from test logic. External connections also facilitate continuous integration and deployment processes by allowing tests to pull the latest data from central repositories.

Web services connections enable UFT to interact with REST or SOAP web services, retrieving data for parameterization from external APIs. This capability is particularly valuable for testing modern applications that rely on microservices architectures.

' Example of Connecting to an External Database
' This code demonstrates how to connect to a database and retrieve data for parameterization
Dim conn, rs, sql
Set conn = CreateObject("ADODB.Connection")
conn.Open "Provider=SQLOLEDB;Data Source=ServerName;Initial Catalog=DatabaseName;User ID=UserID;Password=Password;"
Set rs = CreateObject("ADODB.Recordset")
sql = "SELECT username, password FROM users WHERE status = 'active'"
rs.Open sql, conn

Do While Not rs.EOF
    DataTable.AddSheet "ExternalData"
    DataTable.SetCurrentRow DataTable.GetSheet("ExternalData").GetRowCount + 1
    DataTable("Username", "ExternalData") = rs("username")
    DataTable("Password", "ExternalData") = rs("password")
    rs.MoveNext
Loop

rs.Close
conn.Close

Best Practices for Parameterization

Effective parameterization requires more than just technical knowledge—it demands a strategic approach to data management and test organization. Implementing best practices ensures that parameterized tests remain maintainable, efficient, and scalable as testing requirements evolve.

First and foremost, organize test data effectively:

• Use descriptive column names that clearly indicate the purpose of each parameter
• Group related parameters together in logical sections of the Data Table
• Implement consistent naming conventions across all Data Tables
• Document complex data structures and dependencies

Data security is another critical consideration:

• Store sensitive information like passwords and API keys in environment variables rather than Data Tables
• Implement encryption for external data connections when dealing with confidential information
• Restrict access to test data repositories based on user roles and responsibilities
• Regularly audit test data for security vulnerabilities

Performance optimization is essential for maintaining efficient test execution:

• Minimize the size of Data Tables to only include necessary test data
• Use appropriate data types to reduce memory overhead
• Implement pagination when dealing with large datasets
• Cache frequently accessed external data to reduce connection overhead

By following these best practices, testers can create parameterized tests that are not only functional but also maintainable, secure, and performant. This strategic approach to parameterization ensures that testing efforts scale effectively with project complexity and requirements.

Real-World Examples and Use Cases

Parameterization in UFT finds applications across various testing scenarios, from simple form validations to complex business process testing. Understanding real-world examples helps testers identify opportunities to apply parameterization techniques in their own testing environments.

One common use case is testing login functionality with multiple user credentials. Instead of creating separate tests for each user, parameterization allows testers to create a single test that iterates through a list of usernames and passwords. This approach significantly reduces maintenance overhead and ensures consistent test execution across different user scenarios.

E-commerce applications provide another excellent example of parameterization in action. Testing product searches, cart additions, and checkout processes with various products, quantities, and payment methods can be efficiently handled through parameterization. The Data Table can store product details, user information, and payment scenarios, allowing testers to validate the entire user journey with minimal script modifications.

Here's an example of parameterizing an e-commerce checkout process:

' Example of parameterizing e-commerce checkout in UFT

' Function to add product to cart
Function AddToCart(productID, quantity)
    Browser("MyStore").Page("ProductPage").WebEdit("productID").Set productID
    Browser("MyStore").Page("ProductPage").WebEdit("quantity").Set quantity
    Browser("MyStore").Page("ProductPage").WebButton("AddToCart").Click
End Function

' Function to complete checkout
Function Checkout(paymentMethod, cardNumber, expiryDate, CVV)
    ' Navigate to checkout
    Browser("MyStore").Link("Checkout").Click
    
    ' Select payment method
    Browser("MyStore").Page("Checkout").WebRadio("paymentMethod").Select paymentMethod
    
    ' Enter payment details
    If paymentMethod = "CreditCard" Then
        Browser("MyStore").Page("Checkout").WebEdit("cardNumber").Set cardNumber
        Browser("MyStore").Page("Checkout").WebEdit("expiryDate").Set expiryDate
        Browser("MyStore").Page("Checkout").WebEdit("CVV").Set CVV
    End If
    
    ' Complete purchase
    Browser("MyStore").Page("Checkout").WebButton("CompletePurchase").Click
End Function

' Main test execution
For i = 1 To DataTable.GetRowCount(dtGlobalSheet)
    ' Add product to cart
    AddToCart DataTable("ProductID", dtGlobalSheet), DataTable("Quantity", dtGlobalSheet)
    
    ' Complete checkout
    Checkout DataTable("PaymentMethod", dtGlobalSheet), _
           DataTable("CardNumber", dtGlobalSheet), _
           DataTable("ExpiryDate", dtGlobalSheet), _
           DataTable("CVV", dtGlobalSheet)
    
    ' Verify order confirmation
    Browser("MyStore").Page("Confirmation").Sync
    Reporter.ReportEvent micPass, "Checkout Test", "Order completed successfully"
Next

In conclusion, parameterization in UFT is a powerful technique that significantly enhances the flexibility and maintainability of automated tests. By leveraging advanced data table manipulation techniques and external connections, testers can create sophisticated test scenarios that closely mimic real-world usage. As testing requirements continue to evolve, mastering parameterization becomes increasingly essential for creating robust, scalable, and efficient test automation solutions.

Frequently Asked Questions

• What is parameterization in UFT?
  Parameterization in UFT replaces hardcoded values with variables that can take different values during test execution, allowing the same test to run with multiple data sets.
• What are the main types of parameterization in UFT?
  UFT offers data table parameters, environment variables, random number parameters, and test/action parameters to suit different testing requirements.
• How can I connect to external databases in UFT?
  UFT can connect to external databases using ADO objects with connection strings, execute SQL queries, and process results for parameterization.
• What are best practices for UFT parameterization?
  Organize test data effectively, store sensitive information in environment variables, optimize performance by minimizing data table size, and implement consistent naming conventions.
• How does parameterization improve test maintenance?
  Parameterization separates test data from test logic, reducing maintenance effort by up to 60% while expanding test coverage exponentially.