Ask a Flooder 16: How do I use test data with Element? [Video]

Make your load tests more realistic by adding test data files to your script with Flood Element

In this video, I discuss how to make your load testing scripts more realistic by including test data. The load testing tool I use is Flood Element, but you can apply these principles to any tool. You'll find a copy of the Element script I used below.

Transcript

Hi everyone, Nicole van der Hoeven here back with another Ask a Flooder, and this time the question is: How do I use test data with Flood Element?

Now let's talk about why you might want to use test data. In load testing, it's important to make your scripts behave as similarly to real users as possible so that the load that you generate is production-like. The problem is that if you send the same data over and over again to the server, that server is probably going to cache that response. The response being cached means that the server will return the response way faster than it normally would if it had been a unique request. So we can use test data, instead of static data hardcoded in your scripts, to make sure that this doesn't happen.

Using test data can also help us test different responses. For example, let's say we're testing a loan application system, where a user inputs the application ID, the server looks it up, and returns the status of that loan application. Now, loan applications might be in different stages of the process. For instance, some might be saved but not submitted, or maybe they've been submitted but failed the identity verification check.

If we used the same application ID every time, then the server would always return the same status and the same details. Instead, let's create a CSV file that we can use as test data. It might look something like this.

bash
applicationId
A100001
B100002
C100003
D100004

We can have `applicationId` as the single header here, and we can populate this with a list of different application IDs in different stages of the process. That way, when we run the script, the server will have to respond authentically to every request without it being cached.

Now to create our script. This is an empty Element script. To start with, make sure you're importing `TestData` here in the first line of your script.

js
import { step, TestSettings, Until, By, Browser, TestData } from '@flood/element'

The first thing we're going to need to do is to create an interface for the CSV file. Let's call it `AppData`. Within this interface, we'll need to define all the fields that we intend to use in our data file and what type of values we can expect to be in those fields. Looking at our CSV here, we've just got the application ID, so I'm just going to copy that, and it's a mixture of characters and numbers, so I'm going to put that in as a string.

js
interface AppData {
       applicationId : string
   }

Now we need to tell Element how to find this test data. We'll say that it's from the CSV, using the interface we've just created. Now we'll tell Element the filename. In this situation, the CSV file that I'm using is actually in the same directory, so I don't need to specify a path here, but if you're putting it somewhere else, then you'll need to specify the folder and the path to it.

js
TestData.fromCSV<AppData>('applicationids.csv')

Now let's use the data in a step. In real life, you might want to use an application ID to type it into a text field, but for demonstration purposes, I'm just going to show you how to output it to the console log. Printing to the console is also a good way to debug your tests, especially if you're dealing with test data.


We need to let Element know that we want to use AppData. So now, let's output this to the console. Since we're just debugging, let's output the application ID. To actually get the value from the data file, we'll use this syntax:

js
step('Print to console', async (browser: Browser, data: AppData) => {
   
       console.log('application ID: ', `${data.applicationId}`)
 })

By default, Element reads the data files sequentially. The problem with that is we only have a handful of application IDs. So if we wanted to run this one script 100 times, we're going to run out of data. What we can do here is add `circular`. That way, when the script reaches the very last value of the file, the next value it selects will be the first one, and it never runs out of test data.

js
TestData.fromCSV<AppData>('applicationids.csv')
   .circular()

Another thing you might be wondering is how to make it so that Element chooses a random value every time. To do that, we'll also have to add `shuffle`:

js
TestData.fromCSV<AppData>('applicationids.csv')
   .circular()

Now let's try to run the test.

bash
element run test-data.ts

As you can see, it's been finished. The application ID that was selected was indeed a random one because the first one would have started with A. So, it actually chose the last one randomly.

And that's it for test data with Element. Now, this user actually had a follow-up question, which was about unique test data. I'm going to answer that in the next video. Until next time, happy Flooding!

Sample script

js
import { step, TestSettings, Until, By, Browser, TestData } from '@flood/element'
import * as assert from 'assert'
export const settings: TestSettings = {
    loopCount: -1,
    description: 'Test Data',
    screenshotOnFailure: true,
    disableCache: true,
    clearCache: true,
    clearCookies: true,
}
/**

* Test Data
* Version: 1.0
*/

export default () => {

    interface AppData {
        applicationId : string
    }
    TestData.fromCSV<AppData>('applicationids.csv')
   .circular()
   .shuffle()
    step('Print to console', async (browser: Browser, data: AppData) => {
        console.log('application ID: ', `${data.applicationId}`)

    })
}

Start load testing now

It only takes 30 seconds to create an account, and get access to our free-tier to begin load testing without any risk.