WebLOAD

Test Creation

Build load test scenarios more easily and efficiently with WebLOAD. Take advantage of recording, correlation, drag-and-drop building blocks, parameterization and a script debugger. Extend and enhance your script with any logic and integrations, using WebLOAD’s native JavaScript scripting language.

Recording

Record your actions on your target application and WebLOAD automatically translates your actions into a test script. Recording is transparent and automatic with any web technology, including HTTP/HTTPS(SSL,TLS), WebSocket, AJAX, SOAP, HTML5, WebDAV and others.

WebLOAD generates a test script in JavaScript, which provides the flexibility to add any logic, call Java classes and add integrations – with a scripting environment that’s familiar to any web developer.

Dynamic Values Correlation

WebLOAD automatically identifies and replaces dynamic values that are unique for each run of the script, such as session IDs, time, and others. While other load testing tools may require manually editing 1000 lines of code with correlation parameters, WebLOAD generates a dozen blocks of codes that can be fine tuned within minutes. Learn more about WebLOAD’s best-in-class correlation.

Drag-and-Drop Building Blocks

load testing building blocksAccelerate load scenario development by dragging and dropping elements into your script. Select from load test commands (sleep, transaction, timers, exceptions, synchronizations, etc.), Web protocol actions (ftp, smtp, pop, db, etc), actions for database, mobile, multimedia, WebSockets, as well as validation points.

Parameterization

Parameterize your script to simulate real-life users, replace hard-coded values, and avoid caching effect. WebLOAD’s parameterization wizard lets you replace dynamic values in your script with parameters for date, time, random numbers/strings and input files.

Script Debugging

Validate your test script to confirm it runs smoothly following script editing. Identify all issues and errors early on, using breakpoints, Watch and Step elements, and don’t waste valuable time during your full load test runs.

Correlation

 

Automatic Correlation Engine

WebLOAD’s correlation engine identifies and replaces dynamic values which are unique for each run of the script such as session IDs, time, and many others, and replaces them automatically.

WebLOAD’s correlation is unique in that it correctly identifies a very wide number of dynamic values (within URLs, headers, cookies, etc.) with a small number of errors. While other load testing tools may generate over 1000 lines of code script with correlation parameters, requiring lengthy manual adjustments, WebLOAD will generate a dozen blocks of codes that can be fine tuned in minutes.

How it Works

The Correlation engine handles both server-side (such as session id) and client-side (time, date) dynamic values and replaces them automatically.

You can use WebLOAD’s pre-defined rules as well as have the engine learn your application to construct new rules to be used in the future. For more complex scenarios, you can use JavaScript to define your own custom correlation rules, using regular expressions or any other logic.

Once results are displayed you point out the correct values vs. the ones that should be ignored. This is then automatically applied to future runs, so that no manual editing is needed.

Test Execution

Create Realistic Load Scenarios

WebLOAD gives you the ability to simulate realistic and varied load conditions for an unlimited number of users. You can define a variety of scripts, browsers, and network characteristics in a single test run. Through the scheduler, you can control the load build-up in different ways that mimic real-life conditions, including linear, steps, and increments. You can change the load size during execution using an intuitive throttle control, stop for analysis and restart any time.

Distribute the Load

WebLOAD can simulate anywhere from hundreds to millions of virtual users in the full range of internet protocols. Virtual users are designed with a small footprint to optimize hardware usage. From the central console, you can distribute the load across an unlimited number of machines. No matter how many machines you use, wherever they are located, WebLOAD manages the distribution of scripts and parameters and collects all of the data.

Collect Client and User Experience Data

During test execution, the load generator collects detailed client-side statistics. It enables you to track low-level data or complete transactions. Client-side data is averaged in order to provide meaningful load analytics. In addition, a special virtual user called a Probing Client gives you a full picture of the individual user experience rather than generalized application performance. WebLOAD also monitors server-side performance to help you identify and resolve bottlenecks. Read more about server monitoring.

DevOps and Continuous Integration

Incorporate performance testing into your an DevOPs and Continuous Integration (CI) flow, using WebLOAD’s Jenkins plugin. Implement automated decisioning  from within Jenkis, based on the results of your load test. Learn more.

Goal-Oriented Testing

To find out how well your application meets SLAs, you can define a performance goal and let WebLOAD put it to the test. For example, you can define a goal of response time less than three seconds, and WebLOAD will design and run a scenario to test that goal. After execution, WebLOAD reports how well your application held up.

Analytics

Actionable Intelligence

WebLOAD helps you identify performance bottlenecks in your system with over 80 out-of-the-box reports and graphs that let you drill down at any angle and granular level to pinpoint problems.

Customize your reports

Customizable reports let you configure your reports exactly as needed. You can choose from a variety of templates and apply filters, change the design, and customize metrics to suit your exact requirements.

Drill down with APM tools

Use WebLOAD’s built-in integration with application performance management (APM) tools and take root cause analysis one step further. Once you identify a performance issue using WebLOAD you can switch to your APM tool and correlate the WebLOAD transaction to the server-side event. WebLOAD provides built-in integration with Dynatrace and AppDynamics.

Web Analysis Dashboard

The Web Dashboard improves the efficiency of your test analysis and resolution process providing access to performance test results from any web browser or mobile device. Share and communicate results such as response/transaction time, throughput and errors between multiple team members and report performance issues to management. You can:

Customize your own views of results and graphs

View real-time result of tests as they are running

Share a customized report view with colleagues

View results from tablets and smartphones

Server-side performance

Monitoring server performance under load

WebLOAD collects server-side performance data from operating systems, web servers, application servers, and database servers to help you identify the root-cause of problems. By correlating your load scenario with data such as CPU, memory, capacity, processes, disk I/O, queue data, etc, you can quickly track down bottlenecks and pinpoint the weak links in your system.

Server side data is displayed in real time as part of WebLOAD’s results analytics reports. This simple example presents memory degradation as the load size is increased.

WebLOAD’s monitoring is agentless, requiring no server-side installation. It can be configured to handle secure servers located behind a firewall, supports the import of server-side statistics from 3rd party monitoring tools, as well as the export of monitoring data to external systems.

Built-in server monitoring

WebLOAD provides out-of-the-box monitoring for a range of operating systems, web servers, application servers databases.

In addition, WebLOAD supports standard APIs through which servers expose performance data – such as JMX, SNMP, RSTATD, Windows Performance Monitor, SSH, and JDBC.

Root-cause Analysis using APM tools

WebLOAD’s built-in integration with application performance management (APM) tools helps you take root cause analysis one step further. Once you identify a performance issue using WebLOAD you can switch to your APM tool and correlate the WebLOAD transaction to the server-side event. You can accurately identify events behind bottlenecks and quickly resolve issues.

WebLOAD currently provides built-in integration with Dynatrace and AppDynamics.

JavaScript

JavaScript for Performance Load Testing

WebLOAD uses JavaScript as its load test scenarios scripting language, which provides an accessible, standard environment for extending load tests.

The standard JavaScript is enhanced with built-in load testing objects and methods such as:

Protocols objects. For example: wlHttp object with all http functionality such as Get, Post, Delete, etc.   Other examples include wlFTP, wlTCP, etc.

Load methods such as BeginTransaction, End Transaction, timers, etc.

DOM functionality.  WebLOAD parses web pages and creates a DOM which is similar to the web browser

DOM. This makes it easy to go over the DOM, look for specific values and perform any manipulation or validation. For example, the following code crawls a specific page to check its functionality and verifies that all links are valid.

JSON and XML Parser – These objects helps you to convert easily between JSON or XML and JavaScript object.

Java and COM/DCOM objects. You can instantiate Java and COM/DCOM objects and use their methods.

Objects and methods can be easily added to load testing scripts using WebLOAD’s drag-and-drop building blocks interface, eliminating the need to code from scratch. In addition, you can build your own JavaScript libraries, to be used in all tests; for example, a library that executes login and logout for your application.

JavaScript debugging

WebLOAD’s JavaScript debugger ensures your code is written properly and can run smoothly during load testing.

JavaScript load testing example

A web site has custom logic to create a random identifier for the user based on the user name and timestamp. The actual function that performs this on the site is used in the WebLOAD script.

 

Mobile Load Testing

Load Testing With WebLOAD

In this 4 minute video, RadView CTO Yam Shal-Bar demonstrates how to use WebLOAD to test mobile devices.

Creating Mobile Load Tests

WebLOAD provides several ways to load test your system with mobile device usage. You can create mobile test scripts by:

Recording native mobile apps or browser-based apps directly from the mobile handset

Recording from a desktop browser, simulating the mobile browser

Record a desktop script and modify the settings to simulate a mobile browser

No matter how you create the scripts, you can edit them just like any other test in the WebLOAD editor to add parameters, validation and logic.

Executing Mobile Load Tests

During test execution, you can simulate realistic test scenarios by selecting a variety of different browsers, devices and capabilities. We recommend that you mix browser types and connection speeds in the same run in order to better simulate mobile environment.

Mobile Load Testing with a Real Mobile Device

WebLOAD integrates with PerfectoMobile, allowing you to measure the actual experience on a real mobile device while generating load on your system.  You can:

• Test the user experience using different mobile devices and networks
• View combined statistics of both backend load and real mobile device
• Execute PerfectoMobile test scripts from within WebLOAD

Cloud Performance Testing

Use WebLOAD to run performance testing from the cloud by generating load from Amazon EC2 within minutes. With zero installation or setup you can generate load from multiple locations in the world, distribute load between cloud and on premise machines, and pay (Amazon, not us) based on your usage.

Cloud load generator for performance testing

WebLOAD provides a pre-configured public Amazon Machine Image (AMI), which lets you quickly generate virtual user load with minimal setup using your own Amazon account. You can significantly increase your load without having to purchase additional hardware for on-premise machines. Your cloud load testing costs are only based on actual performance test usage, with WebLOAD automatically turning off cloud test machines upon completion of test sessions.

Combine on premise and cloud virtual user load

Distribute load between on premise machines and geographically distributed Amazon cloud machines – to create a real-life scenario that matches your needs or simply to lower your costs.