Jmeter Groovy Scripting – Call External Scripts

In my previous post, Jmeter BeanShell Scripting – Call External Scripts we have discussed how to user Jmeter Bean Shell script to call external .bsh scripts.

Now in this post, we are going to see how to do the same functionality with JSR 223 sampler + Groovy scripting.

It’s always recommended to use JSR 223 Sampler instead of Bean shell Sampler. I recently got a nice comparison between these two in this post – BeanShell Vs JSR223 Sampler

The JSR223 test elements have a compilation feature that can significantly increase performance.

To get benefit from this feature, Use external .groovy Script files instead of in lining them. This will make Jmeter compile them if this feature is available on Script Engine and cache them.

To get additional benefits from Caching and compilation, language engine used for scripting must implement JSR223 compilable interface.

Groovy is one of the JSR223 compilable interface. But Java, Bean Shell and Java script are not.

Since JMeter 2.8, JSR223 Test Elements using external Script file are now pre compiled and this enables great performance enhancements.

So we are going to use JSR223 test elements with external Groovy script files.

Pre Requisites:

Groovy isn’t shipped with Jmeter. So it needs to be downloaded separately.  To get started:

  1. Download latest groovy binary bundle from
  2. Copy all the Jar files under “groovy-{versionNumber}\lib” and paste it into “Jmeter/lib/ext” folder of your Jmeter installation directory.
  3. Restart Jmeter.


Now we are going to do the same scenario as in the previous post. But instead of http requests, I am gonna do FTP Requests. In short following is the scenario.

I have to do upload some flat files to a FTP server through FTP requests and the flat files are available on a sub directory where my test plan file – .JMX file exists. So I have to parse the list of available files and have to pass the file names as input to my FTP Requests.

I am going to create two external groovy script files for this scenario.

One is for listing out the files under sub directory and putting the absolute path of the Flat files it into a Jmeter variable.

Another script is for extracting the file names alone from the absolute path Jmeter variables.

Following is the “FlatFilePathProcessor.groovy” script file content and I have saved this file where our test plan file exists.


String subDirectory = args[0];
String testPlanFile = FileServer.getFileServer().getBaseDir().replace('\\', '/');
//String testPlanFileDir = FilenameUtils.getFullPathNoEndSeparator(testPlanFile).replace('\\', '/');

vars.put("testPlanFileDir", testPlanFile);

File folder = new File(testPlanFile + "/" + subDirectory + "/");
File[] listOfFiles = folder.listFiles();
int counter = 1;
for (File file : listOfFiles) {
if (file.isFile()) {
vars.put(subDirectory + "_" + counter, testPlanFile + "/" + subDirectory + "/" + file.getName());
vars.put("FileNames" + "_" + counter, file.getName());

Following is the “ExtractFileName.groovy” script file content and I have also saved this file where our test plan file exists.

String fullPath = vars.get("FlatFiles");
int index = fullPath.lastIndexOf("/");
String fileName = fullPath.substring(index + 1);
vars.put("FileName", fileName);

Following is the project structure that we are going to create.


Create a test plan and then create a thread group below that.

First we are going to add JSR 223 sampler in our thread group. – the job of this sampler is to call the FlatFilePathProcessor.groovy file with sub directory name as a parameter. So the request will list out the flat files under sub directory and putting the absolute path of each and every flat file it into a Jmeter variable. Following is the request.


Next we are going to create a ForEach Controller, which will loop through the FTP for each flat file variable created in the above step. Following is our controller.


Now we are going to create JSR 223 Pre-processor. The job of this test element is to call ExtractFileName.groovy to extract the file name from the absolute path. Because for FTP request we need both the file name as well as the absolute file path.

Also one more thing I have noticed is, in FlatFilePathProcessor.groovy itself, we have created two variables one contains the absolute path and another for the file name. But now we are under the ForEach controller, which will process/loop through only one variable. I have not seen any reference where the ForEach controller loop through multiple variables. Following is the request.


Here comes the actual FTP Request, with simple response code assertion. We have used two variables here – one for filename that we got from preprocessor [ExtractFileName.groovy] and another for the absolute file path of the flat file which we are going to upload, that we got from sampler [ExtractFileName.groovy].


Add debug sampler and your favorite listener to see this in action.

The source code of the sample program is here –


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s