Getting Gatling To Work Out Some Hack
Besides benchmarking and stress testing, Gatling still has more to it. It has the potential to be turned into a spam engine!
What Is Gatling?
Gatling is actually a benchmark stress test tool that gives you an idea of how your site and server are performing. It measures things like how many user requests can be processed before the server runs out of memory and causes errors.
Getting Gatling Started
Go to gatling-tool.org and download the gatling-charts-highcharts-1.5.2-bundle.tar.gz
Extract gatling-charts-highcharts-1.5.2-bundle.tar.gz to any directory you want.
Setting Up Gatling Simulation Test
Gatling simulation scripts are Scala classes but don’t worry, we don’t need to write out the Scala class from scratch. Usually, the quickest way to tweak a test is to record a Gatling scenario with the Gatling Recorder shell script. The scenario will then be recorded and generated as a Gatling simulation script. From there, we can edit the Gatling simulation script to run the tests we want.
Configuration For The Gatling Recorder
First, enable the proxy listening port in Firefox. In FireFox, make sure you set up your HTTP proxy and SSL proxy. Go to FireFox preference -> Advanced -> Network -> Connection, click on Settings, then you will see the following screen:
For an easy configuration, you can use the default 8000 and 8001 port for HTTP proxy and SSL proxy respectively.
Using The Gatling Recorder
Now that the settings have been configured, we can proceed to use the Gatling recorder. Run the recorder.sh in {Gatling_Root}/bin. The Gatling recorder interface will pop up like the screen above. Make sure the listening ports have the configured values (8000 and 8001 for HTTP proxy and SSL proxy respectively) in the FireFox configuration. The Package and Class Name are just there for setting up the folder path and file structure after the Output Folder. There we will use “packageTest” and “simulationTest”. Press “start” to start recording. In our recording example, we are registering a test customer in a stock Magento Community Edition, v.1.7.0.2 with sample data installed.
The Gatling recorder is recording our HTTP requests of the registration process
Here is the FireFox view of the registration process recording.
Here Is The Simulation Scala Class That We Generated From The Recorder:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
package packageTest import com.excilys.ebi.gatling.core.Predef._import com.excilys.ebi.gatling.http.Predef._import com.excilys.ebi.gatling.jdbc.Predef._import com.excilys.ebi.gatling.http.Headers.Names._import akka.util.duration._import bootstrap._import assertions._class simulationTest extends Simulation { val httpConf = httpConfig .acceptHeader("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8") .acceptEncodingHeader("gzip, deflate") .acceptLanguageHeader("en-US,en;q=0.5") .connection("keep-alive") .userAgentHeader("Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:22.0) Gecko/20100101 Firefox/22.0") val headers_4 = Map( "Content-Type" -> """application/x-www-form-urlencoded""" ) val scn = scenario("Scenario Name") .exec(http("request_1") .get("/") ) .pause(4) .exec(http("request_2") .get("/customer/account/login/") ) .pause(2) .exec(http("request_3") .get("/customer/account/create/") ) .pause(30) .exec(http("request_4") .post("/customer/account/createpost/") .headers(headers_4) .param("""success_url""", """""") .param("""error_url""", """""") .param("""firstname""", """Simulation""") .param("""lastname""", """Test""") .param("""email""", """simulationtest@infielddesign.com""") .param("""password""", """password1""") .param("""confirmation""", """password1""") ) setUp(scn.users(1).protocolConfig(httpConf))} |
Using this simulation Scala class, we can tweak our own version of the benchmark test. We can do things like adding multiple users, changing the rate of users entering the system, apply dynamic data for multiple users, etc. In this recorded script, we can clearly see that none of the http request has any encrypted key as part of the url parameters. Here is a wild thought: we can do a little bit of hacking, like maybe register 25 test customers at once using a modified simulation Scala class.
Here Is The Modified Simulation Scala Class For Registering 25 Test Customers At Once:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
package packageTest import com.excilys.ebi.gatling.core.Predef._import com.excilys.ebi.gatling.http.Predef._import com.excilys.ebi.gatling.jdbc.Predef._import com.excilys.ebi.gatling.http.Headers.Names._import akka.util.duration._import bootstrap._import assertions._class simulationTest25 extends Simulation { val httpConf = httpConfig .acceptHeader("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8") .acceptEncodingHeader("gzip, deflate") .acceptLanguageHeader("en-US,en;q=0.5") .connection("keep-alive") .userAgentHeader("Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:22.0) Gecko/20100101 Firefox/22.0") val headers_4 = Map( "Content-Type" -> """application/x-www-form-urlencoded""" ) val scn = scenario("Scenario Name") .feed(csv("buyers25.csv").queue) .exec(http("request_1") .get("/") ) .pause(4) .exec(http("request_2") .get("/customer/account/login/") ) .pause(2) .exec(http("request_3") .get("/customer/account/create/") ) .pause(30) .exec(http("request_4") .post("/customer/account/createpost/") .headers(headers_4) .param("""success_url""", """""") .param("""error_url""", """""") .param("""firstname""", "${Firstname}") .param("""lastname""", "${Lastname}") .param("""email""", "${Email}") .param("""password""", """password1""") .param("""confirmation""", """password1""") ) setUp(scn.users(25).protocolConfig(httpConf))} |
Here Is The Buyers25.Csv, The CSV File That Contains Dynamic Test Users Data:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
Firstname,Lastname,EmailTest,User1,test1@example.comTest,User2,test2@example.comTest,User3,test3@example.comTest,User4,test4@example.comTest,User5,test5@example.comTest,User6,test6@example.comTest,User7,test7@example.comTest,User8,test8@example.comTest,User9,test9@example.comTest,User10,test10@example.comTest,User11,test11@example.comTest,User12,test12@example.comTest,User13,test13@example.comTest,User15,test15@example.comTest,User16,test16@example.comTest,User17,test17@example.comTest,User18,test18@example.comTest,User19,test19@example.comTest,User20,test20@example.comTest,User21,test21@example.comTest,User22,test22@example.comTest,User23,test23@example.comTest,User24,test24@example.comTest,User25,test25@example.com |
Running The Gatling Simulation
Now we will run the Gatling Simulation by running the gatling.sh in {Gatling_Root}/bin
The terminal is showing the process of the Gatling simulation test.
The is how the customer_entity table looks before the 25 test users simulation.
The is how the customer_entity table looks after the 25 test users simulation. Note that not the test users are not saved in order because Gatling fires all 25 sessions at the same time.
Final Thought
Gatling can certainly do some cool tricks! Gatling does not replace a “spam engine”, but this “hacking” feature allows for light data import in some web applications. What are your thoughts?
