新手区 Gatling 测试脚本编写

xiuxiuing · 2018年10月15日 · 最后由 xiuxiuing 回复于 2018年10月15日 · 139 次阅读

Gatling 基于 Scala 开发的压测工具,我们可以通过录制自动生成脚本,也可以自己编写脚本,大家不用担心,首先脚本很简单常用的没几个,另外 gatling 封装的也很好我们不需要去专门学习 Scala 语法,当然如果会的话会更好。

脚本示例

import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._
class BaiduSimulation extends Simulation {
  //设置请求的根路径
  val httpConf = http.baseURL("https://www.baidu.com")
  /*
    运行100秒 during 默认单位秒,如果要用微秒 during(100 millisecond)
   */
  val scn = scenario("BaiduSimulation").during(100){
    exec(http("baidu_home").get("/"))
  }
  //设置线程数
//  setUp(scn.inject(rampUsers(500) over(10 seconds)).protocols(httpConf))
  setUp(scn.inject(atOnceUsers(10)).protocols(httpConf))
}

脚本编写

Gatling 脚本的编写主要包含下面三个步骤

  • http head 配置
  • Scenario 执行细节
  • setUp 组装

我们以百度为例,进行第一个 GET 请求测试脚本的编写,类必须继承 Simulation

  1. 配置下 head,只是简单的请求下百度首页,所以只定义下请求的 base url,采用默认的 http 配置即可 //设置请求的根路径 val httpConf = http.baseURL("https://www.baidu.com")
  2. 声明 Scenario,指定我们的请求动作

    val scn = scenario("BaiduSimulation").
    exec(http("baidu_home").get("/"))
    

    scenario 里的参数:scenario name
    exec() 里的参数就是我们的执行动作,http("本次请求的名称").get("本次 http get 请求的地址")

  3. 设置并发数并组装

    //设置线程数
    setUp(scn.inject(atOnceUsers(10)).protocols(httpConf))
    

    atOnceUsers:立马启动的用户数,可以理解为并发数

这样我们一个简单的脚本就完成了,可以运行看下效果。

高级教程

Injection -- 注入

注入方法用来定义虚拟用户的操作

setUp(
  scn.inject(
    nothingFor(4 seconds), // 1
    atOnceUsers(10), // 2
    rampUsers(10) over(5 seconds), // 3
    constantUsersPerSec(20) during(15 seconds), // 4
    constantUsersPerSec(20) during(15 seconds) randomized, // 5
    rampUsersPerSec(10) to 20 during(10 minutes), // 6
    rampUsersPerSec(10) to 20 during(10 minutes) randomized, // 7
    splitUsers(1000) into(rampUsers(10) over(10 seconds)) separatedBy(10 seconds), // 8
    splitUsers(1000) into(rampUsers(10) over(10 seconds)) separatedBy atOnceUsers(30), // 9
    heavisideUsers(1000) over(20 seconds) // 10
  ).protocols(httpConf)
)
  1. nothingFor(duration):设置一段停止的时间
  2. atOnceUsers(nbUsers):立即注入一定数量的虚拟用户 setUp(scn.inject(atOnceUsers(50)).protocols(httpConf))
  3. rampUsers(nbUsers) over(duration):在指定时间内,设置一定数量逐步注入的虚拟用户 setUp(scn.inject(rampUsers(50) over(30 seconds)).protocols(httpConf))
  4. constantUsersPerSec(rate) during(duration):定义一个在每秒钟恒定的并发用户数,持续指定的时间 setUp(scn.inject(constantUsersPerSec(30) during(15 seconds)).protocols(httpConf))
  5. constantUsersPerSec(rate) during(duration) randomized:定义一个在每秒钟围绕指定并发数随机增减的并发,持续指定时间 setUp(scn.inject(constantUsersPerSec(30) during(15 seconds) randomized).protocols(httpConf))
  6. rampUsersPerSec(rate1) to (rate2) during(duration):定义一个并发数区间,运行指定时间,并发增长的周期是一个规律的值 setUp(scn.inject(rampUsersPerSec(30) to (50) during(15 seconds)).protocols(httpConf))
  7. rampUsersPerSec(rate1) to(rate2) during(duration) randomized:定义一个并发数区间,运行指定时间,并发增长的周期是一个随机的值 setUp(scn.inject(rampUsersPerSec(30) to (50) during(15 seconds) randomized).protocols(httpConf))
  8. heavisideUsers(nbUsers) over(duration):定义一个持续的并发,围绕和海维赛德函数平滑逼近的增长量,持续指定时间(译者解释下海维赛德函数,H(x) 当 x>0 时返回 1,x<0 时返回 0,x=0 时返回 0.5。实际操作时,并发数是一个成平滑抛物线形的曲线) setUp(scn.inject(heavisideUsers(50) over(15 seconds)).protocols(httpConf))
  9. splitUsers(nbUsers) into(injectionStep) separatedBy(duration):定义一个周期,执行 injectionStep 里面的注入,将 nbUsers 的请求平均分配 setUp(scn.inject(splitUsers(50) into(rampUsers(10) over(10 seconds)) separatedBy(10 seconds)).protocols(httpConf))
  10. splitUsers(nbUsers) into(injectionStep1) separatedBy(injectionStep2):使用 injectionStep2 的注入作为周期,分隔 injectionStep1 的注入,直到用户数达到 nbUsers setUp(scn.inject(splitUsers(100) into(rampUsers(10) over(10 seconds)) separatedBy atOnceUsers(30)).protocols(httpConf))
循环
val scn = scenario("BaiduSimulation").
    exec(http("baidu_home").get("/"))

上面的测试代码运行时只能跑一次,为了测试效果,我们需要让它持续运行一定次数或者一段时间,可以使用下面两个方式:

  • repeat repeat(times,counterName) times:循环次数 counterName:计数器名称,可选参数,可以用来当当前循环下标值使用,从0开始 val scn = scenario("BaiduSimulation").repeat(100){ exec(http("baidu_home").get("/")) }
  • during during(duration, counterName, exitASAP) duration:时长,默认单位秒,可以加单位milliseconds,表示毫秒 counterName:计数器名称,可选。很少使用 exitASAP:默认为true,简单的可以认为当这个为false的时候循环直接跳出,可在 循环中进行控制是否继续 /* 运行100秒 during 默认单位秒,如果要用微秒 during(100 millisecond) */ val scn = scenario("BaiduSimulation").during(100){ exec(http("baidu_home").get("/")) }
POST 请求

post 参数提交方式:

  • JSON 方式 import io.gatling.core.Predef._ import io.gatling.core.scenario.Simulation import io.gatling.http.Predef._ class JsonSimulation extends Simulation { val httpConf = http.baseURL("http://127.0.0.1:7001/tst") //注意这里,设置提交内容type val headers_json = Map("Content-Type" -> "application/json") val scn = scenario("json scenario") .exec(http("test_json") //http 请求name .post("/order/get") //post url .headers(headers_json) //设置body数据格式 //将json参数用StringBody包起,并作为参数传递给function body() .body(StringBody("{\"orderNo\":201519828113}"))) setUp(scn.inject(atOnceUsers(10))).protocols(httpConf) }
  • Form 方式 import io.gatling.core.Predef._ import io.gatling.http.Predef._ class FormSimulation extends Simulation { val httpConf = http .baseURL("http://computer-database.gatling.io") //注意这里,设置提交内容type val contentType = Map("Content-Type" -> "application/x-www-form-urlencoded") //声明scenario val scn = scenario("form Scenario") .exec(http("form_test") //http 请求name .post("/computers") //post地址, 真正发起的地址会拼上上面的baseUrl http://computer-database.gatling.io/computers .headers(contentType) .formParam("name", "Beautiful Computer") //form 表单的property name = name, value=Beautiful Computer .formParam("introduced", "2012-05-30") .formParam("discontinued", "") .formParam("company", "37")) setUp(scn.inject(atOnceUsers(1)).protocols(httpConf)) }
  • RawFileBody import io.gatling.core.Predef._ import io.gatling.core.scenario.Simulation import io.gatling.http.Predef._ class JsonSimulation extends Simulation { val httpConf = http.baseURL("http://127.0.0.1:7001/tst") //注意这里,设置提交内容type val headers_json = Map("Content-Type" -> "application/json") val scn = scenario("json scenario") .exec(http("test_json") //http 请求name .post("/order/get") //post url .headers(headers_json) //设置body数据格式 //将json参数用StringBody包起,并作为参数传递给function body() .body(RawFileBody("request.txt")) setUp(scn.inject(atOnceUsers(10))).protocols(httpConf) } txt 的文件内容为 JSON 数据,存放目录/resources/bodies
Feed 动态参数

Gatling 对参数的处理称为 Feeder[供料器],支持主要有:

  • 数组 val feeder = Array( Map("foo" -> "foo1", "bar" -> "bar1"), Map("foo" -> "foo2", "bar" -> "bar2"), Map("foo" -> "foo3", "bar" -> "bar3"))
  • CSV 文件 val csvFeeder = csv("foo.csv")//文件路径在 %Gatling_Home%/user-files/data/
  • JSON 文件 val jsonFileFeeder = jsonFile("foo.json") //json的形式: [ { "id":19434, "foo":1 }, { "id":19435, "foo":2 } ]
  • JDBC 数据 jdbcFeeder("databaseUrl", "username", "password", "SELECT * FROM users")
  • Redis

    可参看官方文档http://gatling.io/docs/2.1.7/session/feeder.html#feeder
    

    使用示例:

    import io.gatling.core.Predef._
    import io.gatling.core.scenario.Simulation
    import io.gatling.http.Predef._
    import scala.concurrent.duration._
    /**
    * region请求接口测试
    */
    class DynamicTest extends Simulation {
    val httpConf = http.baseURL("http://127.0.0.1:7001/test")
    //地区 feeder
    val regionFeeder = csv("region.csv").random
    //数组形式
    val mapTypeFeeder = Array(
        Map("type" -> ""),
        Map("type" -> "id_to_name"),
        Map("type" -> "name_to_id")).random
    //设置请求地址
    val regionRequest =
        exec(http("region_map").get("/region/map/get"))
        //加载mapType feeder
        .feed(mapTypeFeeder)
        //执行请求, feeder里key=type, 在下面可以直接使用${type}
        .exec(http("province_map").get("/region/provinces?mType=${type}"))
        //加载地区 feeder
        .feed(regionFeeder)
        //region.csv里title含有provinceId和cityId,所以请求中直接引用${cityId}/${provinceId}
        .exec(http("county_map").get("/region/countties/map?mType=${type}&cityId=${cityId}&provinceId=${provinceId}"))
    //声明scenario name=dynamic_test
    val scn = scenario("dynamic_test")
            .exec(during(180){ regionRequest
            })
    //在2秒内平滑启动150个线程(具体多少秒启动多少线程大家自己评估哈,我这里瞎写的)
    setUp(scn.inject(rampUsers(150) over (2 seconds)).protocols(httpConf))
    }
    

    注意:通过下面的代码只会第一次调用生成一个随机数,后面调用不变

    exec(http("Random id browse")
            .get("/articles/" + scala.util.Random.nextInt(100))
            .check(status.is(200))
    

    Gatling 的官方文档解释是,由于 DSL 会预编译,在整个执行过程中是静态的。因此 Random 在运行过程中就已经静态化了,不会再执行。应改为 Feeder 实现,Feeder 是 gatling 用于实现注入动态参数或变量的,改用 Feeder 实现:

    val randomIdFeeder = 
        Iterator.continually(Map("id" -> 
            (scala.util.Random.nextInt(100))))
    
    feed(randomIdFeeder)
        .exec(http("Random id browse")
            .get("/articles/${id}"))
            .check(status.is(200))
    

    feed()在每次执行时都会从Iterator[Map[String, T]]对象中取出一个值,这样才能实现动态参数的需求。

如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
共收到 3 条回复 时间 点赞

为了更好的阅读体验,请点击个人网站链接

是说社区的 markdown 不好用么?

xiuxiuing Gatling 性能测试 从入门到精通 中提及了此贴 10月15日 13:08
3楼 已删除
恒温 回复

感觉个人网站里面的渲染效果更好一些

恒温 回复

post 请求部分的代码没有渲染出来

xiuxiuing [该话题已被删除] 中提及了此贴 10月18日 06:01
xiuxiuing 专栏文章:Gatling 教程目录 中提及了此贴 10月19日 08:31
需要 登录 后方可回复, 如果你还没有账号请点击这里 注册