虽然我写了这文章，但是我不建议这种做法，原因很简单，这是把简单事情复杂化。

什么是Cucumber？什么是BDD？这里不细讲，不懂的直接查看官方：https://cucumber.io/
　　什么是Rest Assured？传送门：https://github.com/rest-assured/rest-assured

以下以java为开发语言，快速搭建一个cucumber+Rest Assured的api自动化测试平台。
　　1. 用IDEA 新建一个Maven工程，并pom文件添加如下配置：

  1. <!--ccucumber 相关依赖-->
  2.         <dependency>
  3.             <groupId>info.cukes</groupId>
  4.             <artifactId>cucumber-java8</artifactId>
  5.             <version>1.2.4</version>
  6.             <scope>test</scope>
  7.         </dependency>
  9.         <dependency>
  10.             <groupId>info.cukes</groupId>
  11.             <artifactId>cucumber-java</artifactId>
  12.             <version>1.2.4</version>
  13.         </dependency>
  15.         <!-- https://mvnrepository.com/artifact/info.cukes/cucumber-html -->
  16.         <dependency>
  17.             <groupId>info.cukes</groupId>
  18.             <artifactId>cucumber-html</artifactId>
  19.             <version>0.2.3</version>
  20.         </dependency>
  22.         <!--rest-assured 接口测试框架-->
  23.         <!-- https://mvnrepository.com/artifact/com.jayway.restassured/rest-assured -->
  24.         <dependency>
  25.             <groupId>com.jayway.restassured</groupId>
  26.             <artifactId>rest-assured</artifactId>
  27.             <version>2.9.0</version>
  28.         </dependency>
  30.         <!-- https://mvnrepository.com/artifact/org.testng/testng -->
  31.         <dependency>
  32.             <groupId>org.testng</groupId>
  33.             <artifactId>testng</artifactId>
  34.             <version>6.9.10</version>
  35.         </dependency>
  37.         <!--log 引入-->
  38.         <dependency>
  39.             <groupId>log4j</groupId>
  40.             <artifactId>log4j</artifactId>
  41.             <version>1.2.17</version>
  42.         </dependency>
  44.         <dependency>
  45.             <groupId>org.slf4j</groupId>
  46.             <artifactId>slf4j-log4j12</artifactId>
  47.             <version>1.7.5</version>
  48.             <scope>provided</scope>
  49.         </dependency>
  51.         <!--compare jsoon-->
  52.         <dependency>
  53.             <groupId>net.javacrumbs.json-unit</groupId>
  54.             <artifactId>json-unit</artifactId>
  55.             <version>1.13.0</version>
  56.         </dependency>
  58.         <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
  59.         <dependency>
  60.             <groupId>com.fasterxml.jackson.core</groupId>
  61.             <artifactId>jackson-databind</artifactId>
  62.             <version>2.8.1</version>
  63.         </dependency>
  1. 新建个ApiTools类，并对Rest Assured进程二次封装，主要是Post 和 Get请求的基础封装和对返回json解析的封装，具体代码如下：
  1. /**
  2.      * 带json的post请求
  3.      *
  4.      * @param apiPath api地址
  5.      * @param json    请求json
  6.      * @return api返回的Response
  7.      */
  8.     public static Response post(String apiPath, String json) {
  9. //        开始发起post 请求
  10.         String path = Parameters.BOSEHOST + apiPath;
  11.         Response response = given().
  12.                 contentType("application/json;charset=UTF-8").
  13.                 headers("header1", "value1").
  14.                 cookies("cookies1", "value1").
  15.                 body(json).
  16.                 when().log().all().post(path.trim());
  17.         log.info(response.statusCode());
  18.         log.info("reponse:");
  19.         response.getBody().prettyPrint();
  20.         return response;
  21.     }
  23.     /**
  24.      * get 请求
  25.      *
  26.      * @param apiPath api路径
  27.      * @return api的response
  28.      */
  29.     public static Response get(String apiPath) {
  30. //        开始发起GET 请求
  31.         String path = Parameters.BOSEHOST + apiPath;
  32.         Response response = given().
  33.                 contentType("application/json;charset=UTF-8").
  34.                 headers("headers1", "value1").
  35.                 cookie("cookie1", "value1").
  36.                 when().log().all().get(path.trim());
  37.         log.info(response.statusCode());
  38.         log.info("reponse:");
  39.         response.getBody().prettyPrint();
  40.         return response;
  41.     }
  43.     /**
  44.      * 获取json中某个key值
  45.      * @param response  接口返回
  46.      * @param jsonPath  jsonpath, 例如 a.b.c   a.b[1].c  a
  47.      * @return
  48.      */
  49.     public static String getJsonPathValue(Response response, String jsonPath) {
  50.         String reponseJson = String.valueOf(response.jsonPath().get(jsonPath));
  51. //        String jsonValue = String.valueOf(from(reponseJson).get(jsonPath));
  52.         return reponseJson;
  53.     }

3.新建个Steps 类，完成常用step的封装，具体代码如下：

  1. import com.jayway.restassured.response.Response;
  2. import com.tools.apitools.ApiTools;
  3. import com.tools.apitools.MyAssert;
  4. import com.tools.filetools.ReadTxtFile;
  5. import cucumber.api.java.en.Then;
  6. import cucumber.api.java.en.When;
  7. import static net.javacrumbs.jsonunit.JsonAssert.assertJsonEquals;
  8. /**
  9.  * Created by MeYoung on 8/1/2016.
  10.  * <p>
  11.  * Steps 集合
  12.  */
  13. public class Steps {
  15.     Response response = null;
  17.     @When("^I send a GET request to \"(.*?)\"$")
  18.     public void getRequest(String path) {
  19.         response = ApiTools.get(path);
  20.     }
  22.     @When("^I send a POST request to \"(.*?)\"$")
  23.     public void postRequest(String apiPath) throws Throwable {
  24.         response = ApiTools.post(apiPath);
  25.     }
  27.     @When("^I send a POST request to \"(.*?)\" and request json:$")
  28.     public void postRequestWithJson(String apiPath, String json) {
  29.         response = ApiTools.post(apiPath, json);
  30.     }
  32.     @When("^I use a \"(.*?)\" file to send a POST request to \"(.*?)\"$")
  33.     public void postRequestWihtFile(String fileName, String path) {
  34.         String json = ReadTxtFile.readTxtFile(fileName);
  35.         response = ApiTools.post(path, json);
  36.     }
  38.     @Then("^the JSON response equals$")
  39.     public void assertResponseJson(String expected) {
  40.         String responseJson = response.body().asString();
  41.         assertJsonEquals(responseJson, expected);
  42.     }
  44.     @Then("^the JSON response equals json file \"(.*?)\"$")
  45.     public void theJSONResponseEqualsJsonFile(String fileName) {
  46.         String responseJson = response.body().asString();
  47.         String fileJson = ReadTxtFile.readTxtFile(fileName);
  48.         assertJsonEquals(responseJson, fileJson);
  49.     }
  51.     @Then("^the response status should be \"(\\d{3})\"$")
  52.     public void assertStatusCode(int statusCode) {
  53.         Object jsonResponse = response.getStatusCode();
  54.         MyAssert.assertEquals(jsonResponse, statusCode);
  55.     }
  57.     @Then("^the JSON response \"(.*?)\" equals \"(.*?)\"$")
  58.     public void assertEquals(String str, String expected) {
  59.         String jsonValue = ApiTools.getJsonPathValue(response, str);
  60.         MyAssert.assertEquals(jsonValue, expected);
  61.     }
  63.     @Then("^the JSON response \"(.*?)\" type should be \"(.*?)\"$")
  64.     public void assertMatch(String str, String match) {
  65.         String jsonValue = ApiTools.getJsonPathValue(response, str);
  66.         MyAssert.assertMatch(jsonValue, match);
  67.     }
  69.     @Then("^the JSON response \"(.*?)\" should be not null$")
  70.     public void assertNotNull(String str) {
  71.         String jsonValue = ApiTools.getJsonPathValue(response, str);
  72.         MyAssert.assertNotNull(jsonValue);
  73.     }
  75.     @Then("^the JSON response \"(.*?)\" start with \"(.*?)\"$")
  76.     public void assertStartWith(String str, String start) {
  77.         String jsonValue = ApiTools.getJsonPathValue(response, str);
  78.         MyAssert.assertStartWith(jsonValue, start);
  79.     }
  80.     @Then("^the JSON response \"(.*?)\" end with \"(.*?)\"$")
  81.     public void assertEndWith(String str, String end) {
  82.         String jsonValue = ApiTools.getJsonPathValue(response, str);
  83.         MyAssert.assertEndWith(jsonValue, end);
  84.     }
  85.     @Then("^the JSON response \"(.*?)\" include \"(.*?)\"$")
  86.     public void assertInclude(String str, String include) {
  87.         String jsonValue = ApiTools.getJsonPathValue(response, str);
  88.         MyAssert.assertInclude(jsonValue, include);
  89.     }
  90. }

当然上面代码还涉及到一些Asssert的封装，这里就不列出来，个人喜好不同，更具自己熟悉的情况去引入自己熟悉的jar包。

ok，最后我们愉快的写两个case，看看效果：

@get
  Scenario Outline: use examples
    When I send a GET request to "apiurl"
    Then the response status should be "200"
    Then the JSON response "<jsonPath>" equals "<value>"
    Examples:
      | jsonPath     | value             |
      | genericPlan  | false             |
      | ehiCarrierId | 90121100          |
      | carrierName  | Anthem Blue Cross |

  @post
  Scenario: test post request
    When I send a POST request to "apiurl"
    Then the response status should be "200"
    And the JSON response "message" equals "success"
    #    校验放回值是否是某种类型
    And the JSON response "sessionId" type should be "^\d{6}$"
    #    校验返回值不为空
    And the JSON response "url" should be not null
    #    校验是否以XX开头
    Then the JSON response "message" start with "su"
    #    校验是否以XX开头
    Then the JSON response "message" end with "ss"
    #    校验是否以XX开头
    Then the JSON response "message" include "ss"
    #    校验返回json是否为XXX，对整个返回json的校验
    Then the JSON response equals
    """
      {
          "result":"success"
      }
    """

通过Junit 运行feature.

  1. 在Pom.xml 文件添加junit相关包：
<dependency>
            <groupId>info.cukes</groupId>
            <artifactId>cucumber-junit</artifactId>
            <version>1.2.4</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
  1. 在feature 同级目录下新建个运行类，代码例子如下：
import cucumber.api.CucumberOptions;
import cucumber.api.junit.Cucumber;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions(
        strict = true,
        monochrome = true,
        plugin = {"pretty", "html:target/cucumber", "json:target/cucumber.json"},
        features = {"src/test/java/bosev2"},
        glue = {"com.bose.step"},
        tags = {"~@unimplemented"})
public class RunnerBoseTest {
}

RunWith(Cucumber.class) ： 注解表示通过Cucumber的Junit 方式运行脚本
CucumberOptions () ：注解用于配置运行信息，其中代码中的plugin 表示测试报告输出的路径和格式， feature 表示被运行的feature文件的包路径， glue中配置steps的包路径地址，tags中配置要运行的用例的tags名，其实~符号表示除了这个tags的所有tags.

通过Jenkins 执行

  1. 在Pom.xml 文件里面添加运行插件，如下：
<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <inherited>true</inherited>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.18.1</version>
                <configuration>
                    <reuseForks>false</reuseForks>
                </configuration>
            </plugin>
        </plugins>
    </build>
  1. 在Jenkins 中添加Cucumber-JVM reports插件。
  2. 新建Maven job，配置maven构建方式和构建后的测试报告展示。

24-1-Cucumber Rest-Assured快速搭建api自动化测试平台 - 图1

Cucumber-JVM reports 提供了非常漂亮的report，如下：

24-1-Cucumber Rest-Assured快速搭建api自动化测试平台 - 图2

最后附上项目地址：https://github.com/MeYoung/cucumber_restassured