Hi All,

Here I will provide the tips for load testing tool openSTA.

Creating Scripts
Creating Scripts involves deciding how you expect clients to use the WAE under test, then recording browser sessions which incorporate this behavior to produce Scripts. Scripts encapsulate the browser requests issued during a Web session at the HTTP/S level and form the basis of your Tests.

Browser requests and WAE responses are recorded using the OpenSTA Gateway. It is launched automatically when you begin recording a Script using the Script Modeler Module. The Gateway records the HTTP/S requests issued by a browser during Web sessions using SCL scripting language, which enables you to model their content.

Creating Scripts is a separate procedure within the Test development process, and can be carried out independently of Test and Collector creation

Modeling Scripts
Modeling Scripts involves identifying and editing SCL code that represents user input during a browser session, so that the Scripts can be used in Tests to function as one or more Virtual Users during a Test-run. Modeling Scripts enables you to develop Tests that more accurately simulate the Web activity you want to reproduce during a Test-run.

Modeling Scripts is not an essential procedure, particularly if the WAE under test comprises static content only. But it is a useful facility if you need to record the dynamic changes of a WAE during a session. For example, you may need to use a unique user name and password for each Virtual User, so that the Test more accurately simulates real end user activity. You can achieve this by creating a Script then modeling it to include variables that change the user name and password for each Virtual User, every time the Script is run as part of a Test. Using just one modeled Script it is possible to create all the Virtual Users you need, each with unique identities just like real end users.

Script Modeling is enhanced beyond the addition of variables to a Script. The Web pages issued in response to browser requests are recorded at the same time as a Script is created. In HTTP/S Load there is the capability to use objects from these Web pages to model the corresponding Script. This modeling technique is known as DOM Addressing. This technique can be used to verify the results of a Test by checking the validity of WAE responses during Test-run

The Web Relay Daemon
OpenSTA's distributed software architecture enables Test execution on remote Web-based Hosts. This is achieved using a Web Relay Daemon facility which allows the CORBA-based communications within the OpenSTA architecture to be transmitted between machines that are located over the Web.

The Web Relay Daemon facilitates configuration of the components that comprise the Web Relay environment. These consist of the Web Relay Daemon, a Web server and the OpenSTA architecture. Normal Test control communications use XML over HTTP. OpenSTA Web-based replay allows two modes of file transfer: HTTP or FTP. The system also allows SSL-based data transfer.

Use the Web Relay Daemon to map all the machines that need to connect to one another in an OpenSTA architecture which includes Web-based machines. These facilities offer the full range of OpenSTA communications between single or groups of Web-based machines running OpenSTA.

After configuring the Web Relay Daemon remote Hosts can be selected to run a Task Group as normal

SNMP Collectors

The Simple Network Management Protocol (SNMP) Model and protocol allow state information to be retrieved from nodes in a computer network that are running SNMP agents or are served by proxy agents. A `Network Management Station' sends an SNMP request to the SNMP agent, or proxy agent, which returns the requested data.

The OpenSTA SNMP Module allows SNMP data to be retrieved from Host computers and other devices running SNMP agents using OpenSTA SNMP Collectors. These are created and maintained by the OpenSTA SNMP Configuration Plug-in invoked by Commander. This uses the data in the Management Information Block (MIB) files, supplied with OpenSTA or added by the user, to present the data for selection. A list of the IP addresses of Hosts within a user selected range of IP addresses may also be scanned to identify Hosts running SNMP agents or proxy agents. This list may be used to select an SNMP Collector Host and to view the object data from that Host.

An OpenSTA SNMP Collector defines the data to be retrieved from one or more Hosts. An OpenSTA SNMP Collector is held as a comma-separated data file with the .SMP file extension. SNMP data is retrieved and recorded at user specified intervals throughout all or part of each Test-run by the OpenSTA SNMP Task Group Executer (TExecuter_smp.exe). A different interval may be specified for each SNMP object.

Creating Tests
Creating Tests first involves creating the Scripts and Collectors you want to include in them. Then select the Scripts and Collectors you need from the Repository Window and add them one at a time to a Test. Scripts and Collectors are included in Tests by reference. This means that you can include them in multiple Tests in which different Task Group settings apply.

The Scripts and Collectors you add are known as Tasks which are structured in Script-based and Collector-based Task Groups. A load Test must contain at least one Script-based Task Group which can include one, or a sequence of Scripts. Collector-based Task Groups are optional.

Create and run Collector-only Tests for performance monitoring and data collection within production scenarios. Or alternatively, use a load Test that includes Collectors and disable the Script-Task Groups it includes, to turn off the load element they supply before running the Test within a production monitoring environment.

The Test scenario you want to simulate during a Test-run can be controlled by adjusting the Task Group settings. Assemble the Scripts and Collectors of your Test then select the Task Group settings you want to apply in order to generate the level of load required. For Script-based Task Groups these settings include the Host used, the number of Virtual Users and the number of Script iterations per Virtual User. For Collector-based Task Groups the Host used to run the Task Group can be defined.

Creating Tests is a separate procedure within the Test development process, and can be carried out independently of Script and Collector creation

NT Performance Collectors

Windows NT and Windows 2000 include a graphical tool, the Performance Monitor, for viewing performance data on these systems. The OpenSTA NT Performance Module allows the performance data displayed by this tool and retrieved by the NT Performance facility to be recorded within OpenSTA.

OpenSTA allows NT Performance data to be retrieved from Hosts running Windows NT or Windows 2000 using OpenSTA NT Performance Collectors, created and maintained by the OpenSTA NT Performance Configuration Plug-in invoked by Commander. An OpenSTA NT Performance Collector defines the data to be retrieved from one or more Hosts. An NT Performance Collector is held as a comma-separated data file with the .NTP file extension.
NT Performance data is retrieved at user specified intervals throughout each Test-run by the OpenSTA NT Performance Task Group Executer (TExecuter_ntp. exe).

OpenSTA's NT Performance Task Group Executer uses the Windows API to retrieve the required data.

Windows Performance data retrieved by the OpenSTA NT Performance Task Group Executer can be monitored as it is retrieved using the NT Performance Plug-in within Commander. The data is stored in local files, one data file per Executer. These files are closed and copied to the Test-run folder of the OpenSTA Repository on the Repository Host when Test execution is complete

Creating Collectors
Creating Collectors involves deciding which Host computers or other devices to collect performance data from and the type of data to collect during a Test-run. HTTP/S Load supports the creation of NT Performance for recording performance data from Hosts running Windows NT or Windows 2000, and SNMP Collectors for collecting SNMP data from Hosts and other devices running an SNMP agent or proxy SNMP agent.

Collector-based Task Groups can be monitored during a Test-run. The data collected can be displayed alongside other results to provide information about a Test-run.

Creating Collectors is a separate procedure within the Test development process and can be carried out independently of Test and Script creation.

The Audit, Report and History Logs
OpenSTA maintains an Audit Log of its activity and related events for each Testrun. This file contains informational, warning and error messages from the Test Manager, Task Group Executers and, optionally, messages from Scripts written using the SCL LOG command.
All messages in the Audit Log are time-stamped and indicate the name of the Script being processed, the associated User ID and the corresponding script line number, as applicable. All Time-stamps in the Audit Log and elsewhere are based on the time on the Repository Host. This makes it easier to analyze the results of Tests executed on Hosts with different system clock settings or in different time-zones.

In addition to the Audit Log, OpenSTA may also create two further Test-run logs that may be written to from a Script, a Report Log and a History Log.

The purpose of the Report Log (TestRep.txt) is to record transient information relating to the execution of a Test. Task Group Executers may write messages to this Log, for example to record test-case failures and passes. Messages may also be written to the Log from a Script using the SCL REPORT command. The Report Log can be viewed from the Results tab in Commander.

The purpose of the History Log (TestHis.txt) is to record a history of the executions of a Test. Messages are written to the Log from a Script using the SCL HISTORY command. No OpenSTA process, Test Manager or Task Group Executer, writes messages to this Log. The History Logs for a Test can be viewed from the Results tab in Commander. A separate History Log is maintained for each Test-run. However, all the History Logs for a Test are concatenated to form a single Log when viewed within Commander.

Report and History Logs are stored in the Test-run results folders. Messages within them are time-stamped and indicate the name of the Script being processed, the associated User ID and the script line number, as applicable

The Error Log

Within OpenSTA there is an Error Log (ErrLog.txt). This file will contain all significant error messages from the Test Manager, Task Group Executers and OpenSTA Daemon. The Error Log can be viewed from the Monitoring tab in Commander during a Test-run and from the Results tab.

Error Logs are stored in the Test-run results folders. Messages within them are

Test Manager and Task Group Executer Trace Logs

For each Test-run, a Trace Log is created for the Test Manager and each Task Group Executer. These Logs contain informational, warning and error messages logged by the Test Manager and Task Group Executers respectively. Error messages will also be written to the Audit Log. They are created in the same folder as the corresponding executable images, i.e. \Engines, and are copied to the Test-run results folder on test completion. The Log file names have the following format:

TestManager_PID
TExecuter_htp_IPADR
TExecuter_EID_PID

Tracing Script Activity

Script activity may also be traced at run-time using the SCL NOTE command within Scripts. This command allows a message to be associated with a virtual user. The messages associated with a virtual user, if any, may be viewed within Commander, through the Monitoring tab. By including NOTE commands within Scripts it is possible to trace the flow of execution for virtual users at run-time.

Test Initiator (TestInit.exe)
The Test Initiator utility on the Repository Host may be used to start, stop and kill Tests.
Format:
TestInit -start -T Testname
TestInit -stop
TestInit -kill

Script Compiler (scl.exe)
The script compiler (SCL) is used to compile Scripts created using a Modulespecific Plug-in. Scripts are held in the Scripts folder and have an application specific extension, e.g. .HTP for HTTP Scripts.

SCL generates object files which are executed by a Task Group Executer. A dependency file is also created for each Script that is successfully compiled, this is used to identify items required to compile and run the Script.

Note that the SCL command line used by Commander includes the -I switch to specify the include directory \Scripts\Include, within the Repository.
SCL has the following command line format:
Format:
scl {option(s)} SCL_file
-h --help
-i --confirm
-I inc_path --include=inc_path
-l [on|off] --list=[on|off]
-o obj_file --object=obj_file
-v --log
-V v1+v2{+...} --variant=v1+v2{+...}

Results Tab
Results are stored in the Repository after a Test-run is complete. You can view them by working from the Repository Window to open the Test you want, then click on the Results tab in the Test Pane. Use the Results Window to select the results you want to view in the workspace of the Test Pane. You can reposition the Results Window by floating it over the Main Window to give yourself more room for results display, or close it once you have selected the results options you want to view.

The Results Window
When you click on the Results tab, the Results Window opens automatically. Its default location is on the right-hand side of the Test Pane

Move The Results Window
1. Click on the double bar at the top of the Results Window.
2. Drag, then drop it in the new position within the Main Window.

Resize The Results Window
1. Move your cursor over part of the window edge.
2. Click and drag, then drop the border in the required position.

Customize Graph Display
1. Open a Test and click the Results tab in the Test Pane. The Results Window opens automatically listing all Test-runs associated with the current Test. Results are stored in date and time stamped folders.
2. In the Results Window, double-click on a Test-run folder or click , to open it and display the available results.
3. Click on a graph display results option to open your selection in the Test Pane.
4. Right-click inside the graph and select Customize.
5. Select the Graph Type you want:

Export Test Results
1. Open a Test and click the Results tab of the Test Pane. The Results Window opens automatically listing all Test-runs associated with the current Test. Results are stored in date and time stamped folders.
2. In the Results Window, click next to a Test-run folder or double-click on it to open the folder and view a list of results display options and Task Group results folders.
3. Click next to a results option to display your selection in the Test Pane.
4. Right-click inside the graph or table and select either Export to Excel (graphs), or Export (tables and lists).