I have csv file with 10,000 entries. for each iteration, i want to use few 100's of entries. i have loaded into a java list in JSR223 sampler under only once controller. so that, i can load once and use this master list to retrieve chunk of records every time in other JSR223 samplers. i am not able to access variables "totalrows", "lines" defined in one JSR223 sampler from another JSR223 sampler in different thread group. Any other way apart from using vars.get() to get global scope for variables defined to JSR223 sampler
import org.apache.commons.io.FileUtils;
List lines = FileUtils.readLines(new File("skuinfo.csv"));
int totalrows = lines.size();
Variables are thread related, to be able to share you need to use properties (props in jsr223 test elements).
But I would advise you not to use this method as it will impact performances of JMeter particularly if your code is not correctly developed.
You also need to handle synchronization as objects will be shared among threads.
So it’s better to use built-in mechanism of JMete, ie CSV DataSet and prepare data before test.
Related
My test has 2 API requests.
The parameters passed in 2nd API request body are to be unique every time. So I used JSR223 PreProcessor with groovy to generate that using RandomUtils.
The Thread group is set to have 3 threads with 15 sec Ramp up time and used Loop Controller with Loop count as 10. 1st API is in thread group and 2nd API is in Loop Controller as it needs to run multiple times.
But during test execution, for 2nd API one thread is passing same request body with same parameters multiple times. Because of which the test fails. How is that possible?
It's impossible to state "how is that possible" without seeing your Groovy code.
The most common mistake is using JMeter Functions or Variables in Groovy scripts. As per JSR223 Sampler documentation:
The JSR223 test elements have a feature (compilation) that can significantly increase performance. To benefit from this feature:
Use Script files instead of inlining them. This will make JMeter compile them if this feature is available on ScriptEngine and cache them.
Or Use Script Text and check Cache compiled script if available property.
When using this feature, ensure your script code does not use JMeter variables or JMeter function calls directly in script code as caching would only cache first replacement. Instead use script parameters.
If this is your case - refactor your code to use vars shorthand for JMeterVariables class instance instead of JMeter Functions or Variables syntax and it should resolve your issue.
I'm new to Jmeter and vigorously learning.
I wanted to know how JSR223 Sampler and JSR223 PreProcessor are different, can a sampler be used the same way as the preprocessor?
General difference is that PreProcessor won't be executed unless it has a sampler in its scope which it will be triggered (per sampler)
Pre-Processor element is defined to alter the settings of Samplers in their scope. It will always execute before the actual sampler request.
Specific difference is that JSR223 PreProcessor doesn't have SampleResult available, so for example you can't execute the following example:
SampleResult.setStopTest(true);
The SampleResult ResponseData is set from the return value of the script. If the script returns null, it can set the response directly, by using the method SampleResult.setResponseData(data), where data is either a String or a byte array. The data type defaults to "text", but can be set to binary by using the method SampleResult.setDataType(SampleResult.BINARY).
The SampleResult variable gives the script full access to all the fields and methods in the SampleResult. For example, the script has access to the methods setStopThread(boolean) and setStopTest(boolean).
JSR223 Sampler is a Sampler, so it will generate a SampleResult which will appear in the Test Results (unless you call SampleResult.setIgnore() method)
JSR223 PreProcessor cannot be executed per se, you need to connect it to one (or many) Samplers according to JMeter Scoping Rules so it will be executed before one (or many) samplers. PreProcessors execution time is not reflected in the test results (unless you use a Transaction Controller configured to include it)
Both can run an arbitrary code (it's recommended to stick to Groovy) so which one is to use mostly depends on your use case, if you need to conduct the load and measure the time - go for the Sampler, if you need to set up some data - go for the PreProcessor, etc.
My test configuration :
Loop Controller
--> Beanshell Sampler
vars.put("test", "${__CSVRead(*test,0)}");
Add it to an existing array retrieved from vars.getObject
In the above scenario, I am constructing my request payload dynamically in a loop controller. I had to put the CSVRead function in a separate Beanshell sampler under the loop controller since "${__CSVRead(*test,0)}" was reading the sample line if I use it within a for loop inside the beanshell sampler (interpreted mode).
While the above configuration meets my requirement, my *.jtl files are growing in size even for a 30 minute load test since the BeanShell sampler is getting measured all the time. While I am able to filter the required data by using the FilterResults tool, I want to know how to avoid this during the execution itself like the TestActionSampler
Use one of the following Test Elements instead:
BeanShell PreProcessor
BeanShell PostProcessor
Beanshell Timer
By default Timers and Pre/Post Processors execution time is not included into parent sampler elapsed time (unless you use Transaction Controller explicitly configured to do so), using this approach you will be able to exclude the time, required for constructing payload from test results.
I resolved it by using the following configuration.
Loop Controller
--> Test Action Sampler
--> Beanshell timer returning 0 at the end
vars.put("test", "${__CSVRead(*test,0)}");
Add it to an existing array retrieved from vars.getObject
return 0;
I need to read file once and its result to be processed further in sampler.
My strategy is ThreadGroup--> BeanShell Preprocessor + BeanShell Sampler
My preprocessor should read file once for whole Thread Group and result to be used in Sampler for specific no. of thread.(i do not want to read file for each thread)
I wrote file reader code in preprocessor, now need to use the result in sampler.
Don't use the Beanshell PreProcessor as it will be executed by each thread. Use a separate Thread Group with 1 thread to read the values.
Don't use Beanshell Samplers to create the actual load, in case of more or less severe load it will become a bottleneck.
Use JSR223 Test Elements and "groovy" language for scripting - this way you'll be able to get maximum performance from your code.
Now answers:
int number = ctx.getThread().getThreadNum(); // get current thread number
props.put("value_for_thread_" + number, "foo"); // store some value specific for the specific thread
String value = props.get("value_for_thread_5"); // get value for thread 5
Where:
ctx - is a shorthand for JMeterContext
props - stands for JMeter Properties, an instance of java.util.Properties deriving all the methods and fields, global for the whole JVM instance.
See JavaDocs for aforementioned objects to see what else can be done and Beanshell vs JSR223 vs Java JMeter Scripting: The Performance-Off You've Been Waiting For! guide for instructions on installing groovy scripting engine, scripting best practices and benchmark of Beanshell, JSR223+groovy and Java code.
Use Jmeter variables to store the values you've read, and then use them in subsequent steps. Please note that the pre-processor will run every time your thread loop is executed.
In your beanshell preprocessor, you can store a variable like this:
vars.put("name","value")
and then access it later either as
vars.get("name")
in beanshell, or as ${name} in fields of any other sampler.
Please note that if your preprocessor is part of your main thread group, it will be run every time your thread loops. If this is an expensive operation or values do not change during the run, you might want to use a setup thread group.
I have a BSF sampler that runs a groovy script.
I want to create multiple sample results out of this single script in jmeter.
Is it possible?
...my groovy script will run a junit suite and i want to report each junit test separately. Or my groovy script will make 100 http get and i want to display 100 sampler results.
To achieve this you have to organize loop - e.g. put your BSF Sampler under any suitable logic controller: Loop Controller), While Controller, ForEach Controller, or use possibilities of Thread Group (Loop Count, Number of Threads fields).
This scenario will re-use single instance of your BSF Sampler for each new iteration / thread and produce separate sampler result for each execution.
As well you possibly have to provide different entry data / params to BSF Sampler on each iteration - to parametrize it. In this case you can look at least into CSV Dataset Config (to read from file) or any of postprocessors/extractors (go get data from responses).
Suppose you also look into JSR223 Sampler to use along with groovy scripts for better performance.