How to Run Custom Scripts in NeoLoad

Performance testing teams often reach a point where built-in capabilities are not enough to simulate complex user behavior or integrate with external systems. In such cases, the ability to run custom scripts in NeoLoad becomes a powerful extension of its core functionality. By incorporating custom logic, parameter handling, and third-party integrations, teams can create more realistic and flexible performance tests tailored to their applications.

TLDR: Running custom scripts in NeoLoad allows teams to enhance standard performance tests with advanced logic, external integrations, and dynamic behaviors. Users can implement JavaScript, Java-based actions, command-line scripts, and external programs directly within test scenarios. Proper setup, parameter handling, and error management are essential for reliable execution. With careful design, custom scripts significantly improve test realism and automation capabilities.

NeoLoad supports multiple methods for executing custom scripts, enabling testers to customize requests, manage data dynamically, and extend functionality far beyond basic HTTP transactions. Understanding how and when to use these features ensures both flexibility and stability in performance testing projects.

Why Run Custom Scripts in NeoLoad?

Custom scripts allow testers to:

• Handle complex authentication flows not covered by automatic recording
• Integrate with external APIs during test execution
• Manipulate test data dynamically
• Execute OS-level commands or backend utilities
• Perform advanced validations on server responses

For example, applications that rely on token exchanges, encrypted parameters, or third-party services may require scripting logic to generate values in real time.

Types of Custom Scripts in NeoLoad

NeoLoad supports several scripting mechanisms. Each serves different use cases depending on the technical complexity and environment needs.

1. JavaScript (Built-in Scripting)

JavaScript is the most commonly used scripting option in NeoLoad. It allows users to:

• Manipulate variables
• Parse server responses
• Generate dynamic values
• Implement conditional logic

JavaScript runs directly inside the NeoLoad environment and is ideal for most data-driven or logic-based operations.

2. Java Custom Actions

For advanced functionality, NeoLoad allows testers to write custom Java code. This is particularly useful when:

• Complex encryption or hashing is required
• Integration with Java libraries is necessary
• High-performance computation is involved

The Java code is compiled and integrated into the NeoLoad project as a custom action.

3. Command-Line and External Programs

NeoLoad can execute external programs or shell scripts. This approach is useful for:

• Database preconditioning
• Calling Python or PowerShell scripts
• Interacting with system-level services

Comparison of Custom Script Options

Script Type	Language	Best For	Complexity Level	Runs Inside NeoLoad
JavaScript	JavaScript	Variable manipulation, logic, validation	Low to Medium	Yes
Java Custom Action	Java	Encryption, libraries, complex logic	High	Yes
Command-Line Script	Python, PowerShell, Bash, etc.	External integrations, system tasks	Medium to High	No (runs externally)

How to Add a JavaScript Custom Action

Adding a JavaScript action in NeoLoad is straightforward:

1. Open your User Path in NeoLoad.
2. Right-click where you want the script to run.
3. Select Add → JavaScript Action.
4. Enter your script logic in the editor.
5. Save and test execution.

Scripts can access NeoLoad variables using predefined APIs. For example:

• context.variableManager.getValue(“variableName”)
• context.variableManager.setValue(“variableName”, value)

This allows seamless interaction between test data and custom logic.

How to Create a Java Custom Action

Java custom actions require additional setup:

1. Create a new Java project using NeoLoad’s provided API libraries.
2. Extend the required NeoLoad action interfaces.
3. Implement the business logic.
4. Compile the project into a JAR file.
5. Import the JAR into NeoLoad.

This approach is recommended for advanced teams with Java expertise. It offers flexibility but requires proper version control and dependency management.

Executing External Scripts

To run external programs:

1. Add a Command-Line action in the User Path.
2. Specify the executable path.
3. Pass required parameters.
4. Capture output if needed.

For example, a Python script can generate a temporary access token before an API request is executed.

Key considerations include:

• Execution permissions
• Agent machine configuration
• Environment variables
• Error handling

Managing Variables Inside Scripts

Variable management plays a central role in scripting. Common practices include:

• Reading dynamic server responses and extracting values
• Updating session tokens before subsequent requests
• Conditionally modifying request parameters

NeoLoad allows variables to be shared across transactions, making it possible to maintain state throughout test scenarios.

Best Practices for Running Custom Scripts

To ensure stability and maintainability:

• Keep scripts modular and well-documented
• Avoid heavy computations during high-load scenarios
• Implement proper error handling and logging
• Test scripts independently before full load execution
• Monitor resource usage when executing external programs

Overloading scripts with excessive logic can negatively affect load generators and distort performance metrics.

Common Challenges and Solutions

Script Fails During Load

This may occur due to memory constraints or thread contention. Simplifying logic and optimizing loops can resolve the issue.

Variable Not Updating

Ensure the correct scope is used and confirm the script executes before dependent requests.

External Script Not Found

Verify the absolute file path and confirm that the load generator has proper permissions.

High CPU Usage

Avoid executing resource-intensive external programs frequently during peak virtual user loads.

When to Avoid Custom Scripts

Although powerful, custom scripts should not replace built-in features unnecessarily. NeoLoad already supports:

• Automatic correlation
• Built-in variable extractors
• Data parameterization tools
• Logical containers for condition handling

Using native capabilities first helps maintain cleaner, more maintainable test projects.

Real-World Example Use Case

Consider an application requiring a one-time password generated through a proprietary algorithm. A JavaScript action can:

1. Collect user credentials
2. Generate the encoded authentication signature
3. Insert it into the next HTTP header dynamically

This mimics real application behavior without hardcoding static values, ensuring accurate load simulation.

Security Considerations

Custom scripts may handle sensitive information such as tokens and credentials. Teams should:

• Encrypt sensitive files
• Restrict file permissions
• Avoid logging confidential values
• Use secure variable management practices

Proper governance prevents security risks during testing processes.

Conclusion

Running custom scripts in NeoLoad significantly enhances testing flexibility and realism. Whether using JavaScript for lightweight logic, Java for advanced integrations, or command-line scripts for external processes, teams can craft highly customized performance scenarios. The key lies in selecting the appropriate scripting method, managing variables effectively, and preserving overall system stability. When implemented thoughtfully, custom scripts transform NeoLoad from a testing tool into a powerful automation framework capable of simulating complex production behavior.

FAQ

• What is the easiest way to run custom logic in NeoLoad?
  JavaScript actions are the simplest and most commonly used method for adding custom logic inside a User Path.
• Can NeoLoad execute Python scripts?
  Yes, Python scripts can be executed through the Command-Line action, provided the environment supports Python execution.
• Do custom scripts affect performance test results?
  They can if not optimized properly. Heavy computations or inefficient code may impact load generator performance.
• Is Java knowledge required to use custom scripts?
  No. JavaScript and command-line scripts do not require Java expertise. Java is only necessary for advanced custom actions.
• How can script errors be debugged?
  Use NeoLoad logs, add logging statements within scripts, and validate scripts independently before running full load tests.
• Are custom scripts reusable across projects?
  Yes, especially Java custom actions packaged as JAR files, which can be imported into multiple projects.
• Is it safe to store credentials inside scripts?
  It is not recommended. Credentials should be stored securely using protected variables or secure configuration methods.