soapui groovy脚本汇总

出处：https://www.jianshu.com/p/ce6f8a1f66f4

一、一些内部元件的访问

testRunner.testCase开头

1、向下访问

testRunner.testCase.testSteps[testStepName]
testRunner.testCase.getTestStepByName("新增一个空间")

2、向上访问，用于访问同一项目中的其他testSuites 和 testCase下的元素

testRunner.testCase.testSuite.project.testSuites[testSuiteName].testCases[testCaseName].testSteps[testStepName]

3、几乎所有元件都有get 和set属性的方法

setPropertyValue getPropertyValue
//在下面的4，5，6点中，几乎所有的属性值都可以和对应的get方法互相替换等价

4、获取响应体

myResponse=testRunner.testCase.getTestStepByName("新增一个空间").testRequest.response
myRequest=testRunner.testCase.getTestStepByName("新增一个空间").testRequest
可以替换使用：getTestRequest()，testSteps[testStepName]，getResponse()等。
比较特殊的2个
获取响应作为String
myResponse.contentAsString 或者 myRequest.getResponseContentAsString()
获取响应作为Xml
myResponse.contentAsXml 或者myRequest.getResponseContentAsXml()

5、响应头和请求头

响应头：

testRunner.testCase.getTestStepByName("新增一个空间").testRequest.response.responseHeaders["Location"]
或者testRunner.testCase.getTestStepByName("查询空间详情").testRequest.getResponse().getResponseHeaders("Location")

请求头：

testRunner.testCase.getTestStepByName("查询空间详情").testRequest.requestHeaders
testRunner.testCase.getTestStepByName("查询空间详情").testRequest.getRequestHeaders("Location")

设置请求头

def headerMap = new StringToStringMap()   //
headerMap.put("headerKeyName","HeaderKeyWord")           //添加到map
testRunner.testCase.getTestStepByName("查询空间详情").testRequest.setRequestHeaders(headerMap)

6、获取请求地址

testRunner.testCase.getTestStepByName("查询空间详情").testRequest.path

7、getAt(String) 方法，传入property名字，检索出值

针对testRunner下的所有对象，都可以通过此方法直接获取到 属性，例如：
testRunner.testCase.getTestStepByName("查询空间详情").testRequest.getAt("path")
对应：testRunner.testCase.getTestStepByName("查询空间详情").testRequest.path
testRunner.testCase.getTestStepByName("查询空间详情").testRequest.response.getAt("responseHeaders")
对应：testRunner.testCase.getTestStepByName("查询空间详情").testRequest.requestHeaders

8、获取全部用例并循环

def  testCaseList = testRunner.testCase.testSuite.getTestCaseList()
testCaseList.each{
    if(it.testSteps["Input"])
        it.testSteps["Input"].setPropertyValue("spaceid",uid)
    }

9、相对的获取用例数，getTestCaseCount()

 for(int i=0; i<testSuite.getTestCaseCount(); i++) {
     if (!testSuite.getTestCaseAt(i).isDisabled()) {
     if (!(testSuite.getTestCaseAt(i).getTestStepByName("stepName")).equals()){
   .....
         }
      }
   }

10、获取getTestSuiteCount()

testRunner.testCase.testSuite.project.getTestSuiteCount()

11、获取名称

部分元件只有Label和Name中的一个，测试一下就知道了。
    getLabel() 和getName()大多数情况是等价的
    a. 取test case的名称
    def tc = testRunner.testCase;
    log.info (tc.getLabel());
    b. 取test suite的名称
    def ts = testRunner.testCase.testSuite;
    log.info (ts.getLabel());
  getName()
   取project 名称
   def tp = testRunner.testCase.testSuite.project;
   log.info (tp.getName());

12、在断言中需要使用用例对象的话

messageExchange.modelItem.testCase.testSteps["Properties"].getPropertyValue("userId")

13、全局属性变量访问

对于项目中的属性可分为这么几个级别Global, Project,TestSuite, TestCase
即全局变量、项目级别、用例集级别、单个用例级别
要获得如项目级别的属性变量的话，可以用以下方法
def time_num=context.expand('${#Project#time_num}')        //##号内为定义哪个级别的属性变量，后面为属性名

二、json操作

1、json builder

def createAuthorId = context.expand( '${查询空间详情#Response#$.createAuthorId}' )
def flag = "1"
import groovy.json.JsonBuilder
def json = new JsonBuilder()
json {
userID  createAuthorId
fileflag  flag}
return json

2、json 解析

    如json为：
        {"calendar": [         {"calendar_id":"1705","showtime":"1288927800","endshowtime":"1288931400","allDay":false},
{"calendar_id":"1706","showtime":"1288933200","endshowtime":"1288936800","allDay":false}，
{"calendar_id":"1709","showtime":"1288935600","endshowtime":"1288938900","allDay":false}
] }

import groovy.json.JsonSlurper  
def xresponse = testRunner.testCase.testSteps["getCalendarListByCoid"].testRequest.response.contentAsString  
def slurper = new JsonSlurper()  
def re = slurper.parseText(xresponse)  
//访问顶级元素，返回的是一个列表使用size 获得长度
re.calendar   re.calendar.size()
//访问元素模式  
re.calendar.calendar_id     re.calendar.calendar_id[index]
//另一种访问形式
re['calendar']['calendar_id'][index]
//查找过滤
re.calendar.calendar_id.find{it=='1706'}  //获得的结果是 calendar_id  1706
re.calendar.find{it.calendar_id=='1706'}  //获得的是calendar元素

三、XML操作（解析）

ef groovyUtils = new com.eviware.soapui.support.GroovyUtils(context )
//获取上下文对象,转化成groovyUtils对象
defwsdlResponse=testRunner.testCase.testSteps["发贴"].getTestRequest().getResponseContentAsXml()
log.info("wsdlResponse==="+wsdlResponse)
//获取指定步骤的返回信息并转化成xml
holder = groovyUtils.getXmlHolder(wsdlResponse)
//获取指定节点的值
defmessage=holder.getNodeValue("//ns1:Response[1]/ns1:response[1]/ns1:e[1]/ns1:message[1]")
log.info("获得节点对应的值是"+message)
deffandom_creator_sn=holder.getNodeValue("//ns1:fandom_creator_sn")
log.info("获得节点对应的值是"+fandom_creator_sn)

四、文件操作

直接百度groovy文件操作就好了，用得少不收集了

五、各级别的集合操作

1、TestSteps的操作

testRunner.testCase.testSuite.project.testSuites["互动空间测试用例"].testCases["空间管理测试"].testSteps
=getTestSteps()。都是获取用例下的testStep列表，返回的是 key=object 形式的字典map

getTestStepList() 获取用例下的testStep列表，纯列表

getTestStepCount() 获取数量
getTestStepAt(int)  getTestStepById(java.util.UUID)  通过位置和UUID 查找step

getTestStepsOfType(com.eviware.soapui.impl.wsdl.teststeps.RestTestRequestStep.class) 通过类型过滤查找得到 testSteps列表。

2、testCases操作

testRunner.testCase.testSuite.project.testSuites["互动空间测试用例"].testCases=getTestCases()
返回的是 key=object 形式的字典map

getTestCaseList(), 获取的列表，纯列表
getTestCaseCount(),  获取数量
getTestCaseAt(int), getTestCaseById(java.util.UUID) 通过位置和UUID

3、testSuites操作

testRunner.testCase.testSuite.project.testSuites=getTestSuites()
返回的是 key=object 形式的字典map

getTestSuiteList(),获取的列表，纯列表
getTestSuiteCount() 获取数量
,getTestSuiteAt(int), getTestSuiteById(java.util.UUID) 通过位置和UUID

4、返回是list时操作

testCaseList=testRunner.testCase.testSuite.project.testSuites["互动空间测试用例"].getTestCaseList()
log.info testCaseList[0]  //使用 index访问
//each循环
testCaseList.each{
    it.xxxxx
}

5、返回是map时操作

testStepsMap=testRunner.testCase.testSuite.project.testSuites["互动空间测试用例"].testCases["空间管理测试"].testSteps
//使用名称key访问
log.info testStepsMap["新增一个空间"]  
log.info testStepsMap.get("新增一个空间")
//遍历 使用默认闭包it
testStepsMap.each{
    log.info it.key+"  "+it.value
}
//使用自定义闭包名称遍历
testStepsMap.each{myp->
    log.info myp.key+"  "+myp.value
}

六、数据库操作

1、普通的jdbc编程

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JDBCExample1 {
public static void main(String[] args) {
   Connection con = null;
   Statement stmt = null;
   ResultSet rs = null;
   try{
     Class.forName("org.gjt.mm.mysql.Driver");
     con = DriverManager.getConnection("jdbc:mysql://localhost:3306/words",
          "words", "words");
     stmt = con.createStatement();
     rs = stmt.executeQuery("select * from word");
     while (rs.next()) {
       System.out.println("word id: " + rs.getLong(1) +
           " spelling: " + rs.getString(2) +
           " part of speech: " + rs.getString(3));
     }
   }catch(SQLException e){
     e.printStackTrace();
   }catch(ClassNotFoundException e){
     e.printStackTrace();
   }finally{
     try{rs.close();}catch(Exception e){}
     try{stmt.close();}catch(Exception e){}
     try{con.close();}catch(Exception e){}
  }
}
}

2、grrovy sql

import groovy.sql.Sql
   sql = Sql.newInstance("jdbc:mysql://localhost:3306/words", "words",
          "words", "org.gjt.mm.mysql.Driver")

查出所有行

 sql.eachRow("select * from word"){ row |
      println row.word_id + " " + row.spelling + " " + row.part_of_speech
   }

执行插入操作

wid = 999
spelling = "Nefarious"
pospeech = "Adjective"
sql.execute("insert into word (word_id, spelling, part_of_speech)
  values (${wid}, ${spelling}, ${pospeech})")

使用位置参数

val = sql.execute("select * from word where word_id = ?", [5])

更新

nid = 5
spelling = "Nefarious"
sql.executeUpdate("update word set word_id = ? where spelling = ?", [nid, spelling])

删除

sql.execute("delete from word where word_id = ?" , [5])

创建数据集

sql = Sql.newInstance("jdbc:mysql://localhost:3306/words", "words",
         "words", "org.gjt.mm.mysql.Driver")
   words = sql.dataSet("word")
   words.each{ word |
    println word.word_id + " " + word.spelling
   }
   words.add(word_id:"9999", spelling:"clerisy", part_of_speech:"Noun")

查询结果集的访问

sql.eachRow("select * from word"){ grs |
  println "-1  = " + grs.getAt(-1) //使用索引访问最后一个
  println "2  = " + grs.getAt(2) //使用索引访问第三个
   grs.columName //通过列名访问
}

七、流程控制方面

testRunner.testCase  //可以访问和操作项目中的所有对象
testRunner.fail(....)  testRunner.cancel，结束测试执行
testRunner.gotoTestStepByname("Groovy Script") // goto 表示跳转到哪一步开始执行，会等待当前脚本执行完成再跳转到对应步骤执行
testRunner.runTestStepByname("Groovy Script") //脚本会先去执行这个步骤，然后继续执行当前脚本
context.myProperty="aaaa" //会在上下文中创建一个名为myProperty的属性，赋值为aaa

八、脚本返回值和引用

return UUID.randomUUID()  \\return 返回数据
${Groovy Script#result} \\引用
def result = context.expand( '${Groovy Script#result}' ) \\引用

九、抄的两个实例之一----为所有RestTestRequestStep设置请求头（Cookie，session），以及编码

import com.eviware.soapui.support.types.StringToStringMap
def cookiesList = testRunner.testCase.getTestStepByName("登录").testRequest.response.responseHeaders["Set-Cookie"]   //获得登陆后返回响应中的set-cookie
log.info "cookiesList:" + cookiesList  
def cookieNew =""
cookiesList.each{
     cookieNew = cookieNew+it.split(";")[0]+";";    //拆分得到 SESSION
    }
log.info "Cookie:"+cookieNew
def cookieMap = new StringToStringMap()   //cookiemap
cookieMap.put("Cookie",cookieNew)           //添加到map
//Pass cookie to all testSteps of the project
//将cookieMap设置到项目中的所有RestTestRequestStep，顺带设置编码
def testSuiteList =  testRunner.testCase.testSuite.project.getTestSuiteList()
def testCaseList
def testStepList
testSuiteList.each{
    testCaseList = it.getTestCaseList()
    testCaseList.each{
        //获得RestTestRequestStep类型的testStepList
         testStepList = it.getTestStepsOfType(com.eviware.soapui.impl.wsdl.teststeps.RestTestRequestStep.class)
         testStepList.each{
            if(it.name!="登录"){
                   it.testRequest.setRequestHeaders(cookieMap)
                   it.testRequest.setEncoding("UTF-8")
                  }
        }
    }    
}
log.info "==========Cookie:"+ cookieMap.get("Cookie");

十、抄的两个实例之二----数据库验证

import com.eviware.soapui.support.types.StringToStringMap
def Location= testRunner.testCase.getTestStepByName("新增一个教材册次").testRequest.response.responseHeaders["Location"]
log.info "Location:" + Location[0]
def uid = Location[0].split("/")[-1]
testRunner.testCase.testSteps["Input"].setPropertyValue("uid",uid)
log.info "uid:" + uid
import groovy.sql.Sql
//获取testSuite对象，以获取其中参数
def DBProperties = testRunner.testCase.testSuite
//获取数据库对象
def sql = Sql.newInstance(DBProperties.getPropertyValue( "connection-url" ),DBProperties.getPropertyValue( "sysdb-user-name" ),
          DBProperties.getPropertyValue( "sysdb-password" ),DBProperties.getPropertyValue( "driver-class" ))
def  query = "Select * From inf_book_second Where inf_book_second.uid = '"+ uid +"'"
def raw = sql.firstRow(query )
log.info query
def expect_name  = testRunner.testCase.getTestStepByName( "Properties" ).getPropertyValue('name')
log.info "expect_name: "+expect_name
def actual_name = raw.name
log.info "actual_name: "+actual_name
//断言
assert actual_name ==expect_name

原文地址：https://www.cnblogs.com/MasterMonkInTemple/p/10437112.html