类型注册表

参数类型允许您将 cucumber-expressions 中的参数转换为对象。数据表和文档字符串类型允许您将数据表和文档字符串转换为对象。像步骤定义一样，类型定义是粘合代码的一部分。当放置在粘合代码路径上时，Cucumber 将自动检测到它们。

例如，以下类注册了一个自定义的“Author”数据表类型

package com.example;

import io.cucumber.java.DataTableType;
import io.cucumber.java.en.Given;

import java.util.List;
import java.util.Map;

public class StepDefinitions {

    @DataTableType
    public Author authorEntry(Map<String, String> entry) {
        return new Author(
            entry.get("firstName"),
            entry.get("lastName"),
            entry.get("famousBook"));
    }

    @Given("There are my favorite authors")
    public void these_are_my_favourite_authors(List<Author> authors) {
        // step implementation
    }
}

package com.example

import io.cucumber.java.DataTableType
import io.cucumber.java.en.Given
import kotlin.streams.toList

class StepDefinitions {

    @DataTableType
    fun authorEntry(entry: Map<String, String>): Author {
        return Author(
                entry["firstName"],
                entry["lastName"],
                entry["famousBook"])
    }

    @Given("There are my favorite authors")
    fun these_are_my_favourite_authors(authors: List<Author>) {
        // step implementation
    }
}

package com.example

import io.cucumber.scala.{ScalaDsl, EN}

class StepDefinitions extends ScalaDsl with EN {

    DataTableType { entry: Map[String, String] =>
        Author(
            entry("firstName"),
            entry("lastName"),
            entry("famousBook"))
    }

    Given("There are my favorite authors") { authors: List[Author] =>
        // step implementation
    }
}

参数类型示例

package com.example;

import io.cucumber.java.ParameterType;
import io.cucumber.java.en.Given;

public class StepDefinitions {

    @ParameterType(".*")
    public Book book(String bookName) {
    	return new Book(bookName);
    }	

    @Given("{book} is my favorite book")
    public void this_is_my_favorite_book(Book book) {
        // step implementation
    }
}

package com.example

import io.cucumber.java.ParameterType
import io.cucumber.java.en.Given

class StepDefinitions {

    @ParameterType(".*")
    fun book(bookName: String): Book {
        return Book(bookName)
    }

    @Given("{book} is my favorite book")
    fun this_is_my_favorite_book(book: Book) {
        // step implementation
    }
}

package com.example

import io.cucumber.scala.{ScalaDsl, EN}

class StepDefinitions extends ScalaDsl with EN {

    ParameterType("book", ".*") { bookName: String =>
        Book(bookName)
    }

    Given("{book} is my favorite book") { book: Book =>
        // step implementation
    }
}

文档字符串类型示例

package com.example;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.cucumber.java.DocStringType;
import io.cucumber.java.en.Given;

public class StepsDefinitions {

    private static ObjectMapper objectMapper = new ObjectMapper();

    @DocStringType
    public JsonNode json(String docString) throws JsonProcessingException {
        return objectMapper.readValue(docString, JsonNode.class);
    }

    @Given("Books are defined by json")
    public void books_are_defined_by_json(JsonNode books) {
        // step implementation
    }
}

package com.example

import com.fasterxml.jackson.core.JsonProcessingException
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper
import io.cucumber.java.DocStringType
import io.cucumber.java.en.Given

class StepsDefinitions {

    companion object {
        private val objectMapper = ObjectMapper()
    }

    @DocStringType
    @Throws(JsonProcessingException::class)
    fun json(docString: String): JsonNode {
        return objectMapper.readValue(docString, JsonNode::class)
    }

    @Given("Books are defined by json")
    fun books_are_defined_by_json(books: JsonNode) {
        // step implementation
    }
}

package com.example

import com.fasterxml.jackson.core.JsonProcessingException
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper
import io.cucumber.scala.{ScalaDsl, EN}

object StepsDefinitions {
    private val objectMapper = ObjectMapper()
}

class StepsDefinitions extends ScalaDsl with EN {

    DocStringType("json") { docString: String =>
        objectMapper.readValue(docString, classOf[JsonNode])
    }

    Given("Books are defined by json") { books: JsonNode =>
        // step implementation
    }
}

对于 lambda 定义的步骤定义，有 DataTableType、ParameterType 和 DocStringType 函数

package com.example;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import io.cucumber.java8.En;

import java.util.Map;

public class LambdaStepDefinitions implements En {
    
    private static ObjectMapper objectMapper = new ObjectMapper();

    public LambdaStepDefinitions() {
        
        DataTableType((Map<String, String> entry) -> new Author(
            entry.get("firstName"),
            entry.get("lastName"),
            entry.get("famousBook")
        ));

        ParameterType("book", ".*", (String bookName) -> new Book(bookName));

        DocStringType("json", (String docString) -> 
            objectMapper.readValue(docString, JsonNode.class));
    }
}

package com.example

import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper

import io.cucumber.java8.En

class LambdaStepDefinitions : En {

    init {
        val objectMapper = ObjectMapper()

        ParameterType("book", ".*") { s : String ->
            Book(s)
        }

        DataTableType { entry: Map<String, String> ->
            Author(entry["firstName"], entry["lastName"], entry["famousBook"])
        }

        DocStringType("json") { docString: String -> 
	        objectMapper.readValue(docString, JsonNode::class)
	    }
    }
}

使用 @DefaultParameterTransformer、@DefaultDataTableEntryTransformer 和 @DefaultDataTableCellTransformer 注解，也可以插入一个 ObjectMapper。对象映射器（此示例中的 Jackson）将处理匿名参数类型和数据表条目的转换。

使用 DefaultParameterTransformer、DefaultDataTableEntryTransformer 和 DefaultDataTableCellTransformer 方法，也可以插入一个 ObjectMapper。对象映射器（此示例中的 Jackson）将处理匿名参数类型和数据表条目的转换。

package com.example;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.cucumber.java.DefaultDataTableCellTransformer;
import io.cucumber.java.DefaultDataTableEntryTransformer;
import io.cucumber.java.DefaultParameterTransformer;

import java.lang.reflect.Type;

public class StepDefinitions {

    private final ObjectMapper objectMapper = new ObjectMapper();

    @DefaultParameterTransformer
    @DefaultDataTableEntryTransformer
    @DefaultDataTableCellTransformer
    public Object transformer(Object fromValue, Type toValueType) {
        return objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType));
    }
}

package com.example

import com.fasterxml.jackson.databind.ObjectMapper
import io.cucumber.java.DefaultDataTableCellTransformer
import io.cucumber.java.DefaultDataTableEntryTransformer
import io.cucumber.java.DefaultParameterTransformer

import java.lang.reflect.Type

class StepDefinitions {

    private val objectMapper = ObjectMapper()

    @DefaultParameterTransformer
    @DefaultDataTableEntryTransformer
    @DefaultDataTableCellTransformer
    fun transformer(fromValue: Any, toValueType: Type): Any {
        return objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType))
    }
}

package com.example

import com.fasterxml.jackson.databind.ObjectMapper
import io.cucumber.scala.ScalaDsl

import java.lang.reflect.Type

class StepDefinitions extends ScalaDsl {

    private val objectMapper = ObjectMapper()

    DefaultParameterTransformer { (fromValue: String, toValueType: Type) => 
        objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType)) 
    }

    DefaultDataTableCellTransformer { (fromValue: String, toValueType: Type) => 
        objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType)) 
    }

    DefaultDataTableEntryTransformer { (fromValue: Map[String, String], toValueType: Type) => 
        objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType))
    }
}

对于 lambda 定义的步骤定义，有 DefaultParameterTransformer、DefaultDataTableCellTransformer 和 DefaultDataTableEntryTransformer 方法函数块函数函数

package com.example;

import io.cucumber.java8.En;

import com.fasterxml.jackson.databind.ObjectMapper;

import java.lang.reflect.Type;

public class LambdaStepDefinitions implements En {
    
    public LambdaStepDefinitions() {
        ObjectMapper objectMapper = new ObjectMapper();

        DefaultParameterTransformer((String fromValue, Type toValueType) ->
            objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType)));

        DefaultDataTableCellTransformer((fromValue, toValueType) ->
            objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType)));

        DefaultDataTableEntryTransformer((fromValue, toValueType) ->
            objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType)));
    }
}

import com.fasterxml.jackson.databind.ObjectMapper

import io.cucumber.java8.En
import java.lang.reflect.Type

class LambdaStepDefinitions : En {
    init {
        val objectMapper = ObjectMapper()

        DefaultParameterTransformer { fromValue: String, toValueType: Type -> 
            objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType)) 
        }

        DefaultDataTableCellTransformer { fromValue, toValueType -> 
            objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType)) 
        }

        DefaultDataTableEntryTransformer { fromValue, toValueType -> 
            objectMapper.convertValue(fromValue, objectMapper.constructType(toValueType))
        }
    }
}

参数类型 允许您在将参数传递给步骤定义之前，将其从字符串转换为另一种类型。

例如，让我们定义我们自己的“Person”类型

ParameterType(
  name: 'person',
  regexp: /[A-Z][a-z]+/,
  transformer: -> (name) { Person.new(name) }
)

这是一个在步骤定义中使用它的示例

Then /^a user {person} should have {int} followers$/ do |person, count|
  assert(person.is_a?(Person))
end

如果您使用尚未定义的类型，您将收到类似于以下错误的消息

The parameter type "person" is not defined.

如果您使用尚未定义的类型，您将收到类似于以下错误的消息

The parameter type "person" is not defined.

如果您使用尚未定义的类型，您将收到类似于以下错误的消息

The parameter type "person" is not defined.

如果您使用尚未定义的类型，您将收到类似于以下错误的消息

The parameter type "person" is not defined.

您可以定义自己的参数类型和数据表类型。

有关如何将 参数类型 与 Cucumber-js 一起使用的更多信息，请参阅 parameter_types.feature。

有关如何将 数据表 与 Cucumber-js 一起使用的更多信息，请参阅 cucumber-js 文档。

如果需要，可以使用预定义的 JacksonDefaultDataTableEntryTransformer 特性，该特性使用 Jackson Scala 模块定义默认转换器。

请参阅 Default Jackon DataTable Transformer。

配置文件

Cucumber 配置文件在 Cucumber-JVM 上不可用。但是，可以使用 Maven 配置文件设置配置选项

例如，我们可以为要在不同环境中运行的场景配置单独的配置文件，如下所示

    <profiles>
        <profile>
          <id>dev</id>
            <properties>
                <cucumber.filter.tags>@dev and not @ignore</cucumber.filter.tags>
            </properties>
        </profile>
        <profile>
          <id>qa</id>
            <properties>
                <cucumber.filter.tags>@qa</cucumber.filter.tags>
            </properties>
        </profile>
    </profiles>

    <build>
        <plugins>
            ...
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M4</version>
                <configuration>
                    <systemPropertyVariables>
                       <cucumber.filter.tags>${cucumber.filter.tags}</cucumber.filter.tags>
                    </systemPropertyVariables>
                </configuration>
            </plugin>
        </plugins>
    </build>

要使用 Gradle 模仿类似的行为，请参阅 Gradle 文档，了解迁移 Maven 配置文件和属性。

Cucumber 配置文件在 Cucumber-JVM 上不可用。但是，可以使用 Maven 配置文件设置配置选项

例如，我们可以为要在不同环境中运行的场景配置单独的配置文件，如下所示

    <profiles>
        <profile>
          <id>dev</id>
            <properties>
                <cucumber.filter.tags>@dev and not @ignore</cucumber.filter.tags>
            </properties>
        </profile>
        <profile>
          <id>qa</id>
            <properties>
                <cucumber.filter.tags>@qa</cucumber.filter.tags>
            </properties>
        </profile>
    </profiles>

    <build>
        <plugins>
            ...
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M4</version>
                <configuration>
                    <systemPropertyVariables>
                       <cucumber.filter.tags>${cucumber.filter.tags}</cucumber.filter.tags>
                    </systemPropertyVariables>
                </configuration>
            </plugin>
        </plugins>
    </build>

要使用 Gradle 模仿类似的行为，请参阅 Gradle 文档，了解迁移 Maven 配置文件和属性。

Cucumber 配置文件在 Cucumber-JVM 上不可用。但是，可以使用 Maven 配置文件设置配置选项

例如，我们可以为要在不同环境中运行的场景配置单独的配置文件，如下所示

    <profiles>
        <profile>
          <id>dev</id>
            <properties>
                <cucumber.filter.tags>@dev and not @ignore</cucumber.filter.tags>
            </properties>
        </profile>
        <profile>
          <id>qa</id>
            <properties>
                <cucumber.filter.tags>@qa</cucumber.filter.tags>
            </properties>
        </profile>
    </profiles>

    <build>
        <plugins>
            ...
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M4</version>
                <configuration>
                    <systemPropertyVariables>
                       <cucumber.filter.tags>${cucumber.filter.tags}</cucumber.filter.tags>
                    </systemPropertyVariables>
                </configuration>
            </plugin>
        </plugins>
    </build>

要使用 Gradle 模仿类似的行为，请参阅 Gradle 文档，了解迁移 Maven 配置文件和属性。

有关如何将配置文件与 Cucumber-js 一起使用的更多信息，请参阅 profiles.feature。

您可以在 cucumber.yml 或 cucumber.yaml 文件中指定 Cucumber 的配置选项。此文件必须位于 .config 目录中，或当前工作目录的 config 子目录中。

config/cucumber.yml
## ##YAML Template
html_report: --format progress --format html --out=features_report.html
bvt: --tags @bvt

定义模板需要一个名称，然后是您希望使用此配置文件执行的命令行选项。

上面的示例生成了两个配置文件

html_report，它包含指定新输出格式的命令行选项列表，以及
bvt，它执行所有标记为 @bvt 的 Feature 和 Scenario。

Cucumber-Rails 在项目配置目录中创建一个 cucumber.yml 文件，其中包含多个预定义的配置文件，其中一个是默认配置文件。当从命令行运行 Cucumber 时，通常需要同时提供包含 Feature 文件树的根目录的目录名以及包含对必要库文件的引用的目录名。在一个典型的项目中，cucumber --require features features/some/path 就足够了。重复性的用法可以添加到项目 cucumber.yml 文件中包含的用户定义配置文件中。

要执行配置文件，请使用

\[user@system project] cucumber --profile html_report
\[user@system project] cucumber -p bvt

使用 --profile 或 -p 标志以配置文件执行 Cucumber。如果需要，您仍然可以使用其他命令行参数与 --profile 或 -p 一起使用。

\[user@system project] cucumber --profile html_report --tags ~@wip

甚至可以一起指定多个配置文件。以下操作将执行所有标记为 @bvt 的 Feature 和 Scenario，以及指定的进度和 HTML 输出。

\[user@system project] cucumber -p html_report -p bvt

默认配置文件

Cucumber 配置文件在 Cucumber-JVM 上不可用。见上文。

有关如何将配置文件与 Cucumber-js 一起使用的更多信息，请参阅 profiles.feature。

您可能希望大多数时候使用特定的配置文件执行 Cucumber。Cucumber 配置文件使用 default 配置文件来提供此功能。当您指定 default 配置文件时，您告诉 Cucumber 在您没有明确指定其他配置文件时使用 default 命令行选项。

使用相同的示例，也许我们希望 html_report 配置文件成为我们的默认执行。


1. config/cucumber.yml
   ## ##YAML Template
   default: --profile html_report --profile bvt
   html_report: --format progress --format html --out=features_report.html
   bvt: --tags @bvt

\[user@system project] cucumber

有了这个设置，Cucumber 现在将同时使用 bvt 配置文件和 html_report 配置文件，测试所有标记为 @bvt 的 Feature 和 Scenario，以及进度输出和 HTML 输出。

使用 ERB 预处理

ERB（嵌入式 RuBy）是特定于 Ruby 的工具。

cucumber.yml 文件由 ERB（嵌入式 RuBy）预处理。这允许您使用 Ruby 代码在 cucumber.yml 文件中生成值。

因此，如果您有几个具有相似值的配置文件，您可以这样做


1. config/cucumber.yml
   ## ##YAML Template
   <% common = "--tags ~@wip --strict" %>
   default: <%= common %> features
   html_report: <%= common %> --format html --out=features_report.html features

环境变量

Cucumber-JVM 不支持使用 env 文件配置 Cucumber。

Cucumber-js 不支持使用 env 文件配置 Cucumber。

您可以在配置文件参数列表中使用环境变量，就像您通常在命令行上指定它们一样。


1. config/cucumber.yml
   \##YAML Template
2. ## ie profile executes the browser features with Internet Explorer
   default: --profile html_report --profile bvt
   html_report: --format progress --format html --out=features_report.html
   bvt: --tags @bvt
   ie: BROWSER=IE

当运行 Cucumber 时，有时将特殊值传递给 Cucumber 以供您的步骤定义使用会很方便。

您可以在命令行上执行此操作

   cucumber FOO=BAR --format progress features

您现在可以在 Ruby 中拾取 ENV\['FOO']（例如，在 env.rb 中，或在步骤定义中）并根据值执行操作。

您也可以在 cucumber.yml 中执行此操作。

例如，以下操作设置了一个运行指定标签并设置环境变量的配置文件

   baz: --tags @mytag FOO=BAR

support/env.rb 本身中的本地 Cucumber 自定义代码，因为该文件通常会被 script/generate cucumber:install | rails g cucumber 覆盖。在 Cucumber 初始化之前必须加载的自定义代码必须放在 env.rb 文件 的开头。

Cucumber 会加载 features/support 目录下所有以 `.rb` 结尾的文件。因此，如果你在该目录下的任何 `.rb` 文件中放置本地自定义内容，它们将会被加载。但是，请注意，在 Cucumber < 4.x 中，`--dry-run` 选项只会排除 features/support 目录下与正则表达式 `env\\..\*`匹配的文件（注意尾部点很重要）。因此，名为 `my_locals.rb` 的本地自定义文件将会被加载，无论是否使用 `--dry-run` 选项。在 Cucumber 4.x 中，所有支持文件，包括 `env.rb` 文件，都会被加载。

如果你在 `features/support` 目录中放置了不想在 Cucumber 执行 `dry-run` 时加载的自定义文件，可以使用 `--exclude` 标志来确保它们不被加载。在 Cucumber 版本 < 4.x 中，你也可以在文件名前面加上 `env`，例如 `env.local.rb`。请注意，名为 `local_env.rb` 的文件不匹配上述正则表达式，因此它将在所有版本的 Cucumber 中被加载，除非明确排除。

作为最佳实践，你应该在每次安装更新版本的 Cucumber 或 cucumber-rails 时运行 `script/generate cucumber | rails g cucumber:install`。但是，这会覆盖 `features/support/env.rb` 文件。为了保留你 `env.rb` 文件中的任何自定义配置，请将你的 `env.rb` 文件和其他版本控制文件一起签入，并准备好对不同版本的 Cucumber-Rails 之间的 `env.rb` 文件进行差异比较和合并。

Cucumber 配置

类型注册表

推荐位置

配置文件

默认配置文件

使用 ERB 预处理

环境变量