测试指南 Camel K

首先，我们需要安装并熟悉 jbang 和 camel CLI。您可以按照 Camel JBang 的官方文档 将 CLI 安装到本地环境中。之后，我们可以了解如何使用 Camel JBang 测试 Camel K 集成。

我们开发的第一个应用程序是一个简单的，它定义了在测试 Kubernetes 中最终通过 Camel K 部署的任何集成时必须遵循的流程。验证 Camel K 安装中的 Camel 的目标版本。通过这些信息，我们可以确保针对以后在集群中部署的相同版本进行本地测试。

$ kamel version -a -v | grep Runtime
Runtime Version: 3.8.1

$ kubectl get camelcatalog camel-catalog-3.8.1 -o yaml | grep camel\.version
      camel.version: 3.8.1

以上命令可用于查找集群 Camel K 安装中运行时使用的 Camel 版本。我们的目标是 Camel 版本 3.18.3。

初始化 Camel 路由的最简单方法是运行 camel init 命令：

$ camel init HelloJBang.java

在这个阶段，我们可使用集成所需的逻辑编辑该文件，或者只运行它：

$ camel run HelloJBang.java
2022-11-23 12:11:05.407  INFO 52841 --- [           main] org.apache.camel.main.MainSupport        : Apache Camel (JBang) 3.18.1 is starting
2022-11-23 12:11:05.470  INFO 52841 --- [           main] org.apache.camel.main.MainSupport        : Using Java 11.0.17 with PID 52841. Started by squake in /home/squake/workspace/jbang/camel-blog
2022-11-23 12:11:07.537  INFO 52841 --- [           main] e.camel.impl.engine.AbstractCamelContext : Apache Camel 3.18.1 (CamelJBang) is starting
2022-11-23 12:11:07.675  INFO 52841 --- [           main] e.camel.impl.engine.AbstractCamelContext : Routes startup (started:1)
2022-11-23 12:11:07.676  INFO 52841 --- [           main] e.camel.impl.engine.AbstractCamelContext :     Started java (timer://java)
2022-11-23 12:11:07.676  INFO 52841 --- [           main] e.camel.impl.engine.AbstractCamelContext : Apache Camel 3.18.1 (CamelJBang) started in 397ms (build:118ms init:140ms start:139ms JVM-uptime:3s)
2022-11-23 12:11:08.705  INFO 52841 --- [ - timer://java] HelloJBang.java:14                       : Hello Camel from java
2022-11-23 12:11:09.676  INFO 52841 --- [ - timer://java] HelloJBang.java:14                       : Hello Camel from java
...

本地 java 进程以正在运行的 Camel 应用程序开头。不需要创建 Maven 项目，所有 boilerplate 都位于 Camel JBang!但是，您可能会注意到使用的 Camel 版本与您要目标的 Camel 版本不同。这是因为您的 Camel JBang 使用不同的 Camel 版本。不小心，我们可以重新运行这个应用程序，但指定要运行的 Camel 版本：

$ jbang run -Dcamel.jbang.version=3.18.3 camel@apache/camel run HelloJBang.java
...
[1] 2022-11-23 11:13:02,825 INFO  [org.apa.cam.imp.eng.AbstractCamelContext] (main) Apache Camel 3.18.3 (camel-1) started in 70ms (build:0ms init:61ms start:9ms)
...

下一步是在安装 Camel K 的 Kubernetes 集群中运行它。

我们在这里使用 Camel K 插件进行 Camel JBang，而不是 kamel CLI。这样，您可以使用相同的 JBang 工具在本地和 K8s 集群中使用 Operator 运行 Camel K 集成。JBang 插件文档可在此处找到： Camel JBang Kubernetes。

您会看到 Camel K 操作员需要谨慎进行必要的转换，并根据预期生命周期构建集成和相关资源。当它处于活动状态后，您可以跟踪通常在部署的集成上执行的操作。

这个过程的好处是，在在本地使用 Integration 调整后，您不需要担心远程集群。

集成就绪后，您必须注意与集群部署相关的调整类型。因此，您不必担心开发早期的部署详情。或者您甚至可以有单独的角色，域专家可以在本地开发集成，并且集群专家可以在后续阶段进行部署。

让我们来看看如何开发一个集成的示例，以便稍后在集群中进行一些微调。

import org.apache.camel.builder.RouteBuilder;

public class MyJBangRoute extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("file:/tmp/input")
            .convertBodyTo(String.class)
            .log("Processing file ${headers.CamelFileName} with content: ${body}")
            /*
            .filter(simple("${body} !contains 'checked'"))
                .log("WARN not checked: ${body}")
                .to("file:/tmp/discarded")
            .end()
            .to("file:/tmp/output");
            */
            .choice()
                .when(simple("${body} !contains 'checked'"))
                    .log("WARN not checked!")
                    .to("file:/tmp/discarded")
                .otherwise()
                    .to("file:/tmp/output")
            .end();
    }
}

有一个进程负责将文件写入到目录中。您必须根据其内容过滤这些文件。我们的目的是将代码注释保留下来，因为它是我们迭代开发的方式。我们通过 Camel JBang 在本地测试某个内容，直到我们进入集成的最终版本。我们已测试了 Filter EIP，但在测试时，我们需要一个 基于内容的路由器 EIP。它必须听起来非常熟悉的过程，因为每次开发某项时都会发生。

现在我们已准备好，我们通过 Camel JBang 在本地运行最后一轮测试：

$ jbang run -Dcamel.jbang.version=3.18.3 camel@apache/camel run MyJBangRoute.java
2022-11-23 12:19:11.516  INFO 55909 --- [           main] org.apache.camel.main.MainSupport        : Apache Camel (JBang) 3.18.3 is starting
2022-11-23 12:19:11.592  INFO 55909 --- [           main] org.apache.camel.main.MainSupport        : Using Java 11.0.17 with PID 55909. Started by squake in /home/squake/workspace/jbang/camel-blog
2022-11-23 12:19:14.020  INFO 55909 --- [           main] e.camel.impl.engine.AbstractCamelContext : Apache Camel 3.18.3 (CamelJBang) is starting
2022-11-23 12:19:14.220  INFO 55909 --- [           main] e.camel.impl.engine.AbstractCamelContext : Routes startup (started:1)
2022-11-23 12:19:14.220  INFO 55909 --- [           main] e.camel.impl.engine.AbstractCamelContext :     Started route1 (file:///tmp/input)
2022-11-23 12:19:14.220  INFO 55909 --- [           main] e.camel.impl.engine.AbstractCamelContext : Apache Camel 3.18.3 (CamelJBang) started in 677ms (build:133ms init:344ms start:200ms JVM-uptime:3s)
2022-11-23 12:19:27.757  INFO 55909 --- [le:///tmp/input] MyJBangRoute.java:11                     : Processing file file_1669202367381 with content: some entry

2022-11-23 12:19:27.758  INFO 55909 --- [le:///tmp/input] MyJBangRoute:21                          : WARN not checked!
2022-11-23 12:19:32.276  INFO 55909 --- [le:///tmp/input] MyJBangRoute.java:11                     : Processing file file_1669202372252 with content: some entry checked

我们已测试在输入目录中添加文件。准备推广至我的开发集群！

使用此处的 Camel K JBang 插件在 K8s 上运行集成，因此您不需要切换工具。

运行以下命令:

camel k run MyJBangRoute.java

集成正常启动，但我们使用了文件系统，这是运行集成的 Pod 的本地文件系统。

$ kamel run MyJBangRoute.java --volume my-pv-claim-input:/tmp/input --volume my-pv-claim-output:/tmp/output --volume my-pv-claim-discarded:/tmp/discarded --dev
...
[1] 2022-11-23 11:39:26,281 INFO  [route1] (Camel (camel-1) thread #1 - file:///tmp/input) Processing file file_1669203565971 with content: some entry
[1]
[1] 2022-11-23 11:39:26,303 INFO  [route1] (Camel (camel-1) thread #1 - file:///tmp/input) WARN not checked!
[1] 2022-11-23 11:39:32,322 INFO  [route1] (Camel (camel-1) thread #1 - file:///tmp/input) Processing file file_1669203571981 with content: some entry checked

Camel JBang 的另一个优点在于能够在本地测试 Kamelet。到目前为止，测试 Kamelet 的最简单方法是上传到 Kubernetes 集群，并通过 Camel K 运行一些集成。

让我们开发了此范围的简单 Kamelet。这是一个 Coffee 源，我们用来生成随机的 coffee 事件。

apiVersion: camel.apache.org/v1
kind: Kamelet
metadata:
  name: coffee-source
  annotations:
    camel.apache.org/kamelet.support.level: "Stable"
    camel.apache.org/catalog.version: "4.7.0-SNAPSHOT"
    camel.apache.org/kamelet.icon: "data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://www.w3.org/2000/svg" height="92pt" width="92pt" version="1.0" xmlns:cc="http://creativecommons.org/ns#" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/">
	<defs>
		<linearGradient id="a">
			<stop stop-color="#ffffff" stop-opacity=".5" offset="0"/>
			<stop stop-color="#ffffff" stop-opacity=".1" offset="1"/>
		</linearGradient>
		<linearGradient id="d" y2="62.299" xlink:href="#a" gradientUnits="userSpaceOnUse" y1="33.61" gradientTransform="matrix(.78479 0 0 1.2742 -25.691 -8.5635)" x2="95.689" x1="59.099"/>
		<linearGradient id="c" y2="241.09" xlink:href="#a" gradientUnits="userSpaceOnUse" y1="208.04" gradientTransform="matrix(1.9777 0 0 .50563 -25.691 -8.5635)" x2="28.179" x1="17.402"/>
		<linearGradient id="b" y2="80.909" xlink:href="#a" gradientUnits="userSpaceOnUse" y1="55.988" gradientTransform="matrix(1.5469 0 0 .64647 -25.691 -8.5635)" x2="87.074" x1="70.063"/>
	</defs>
	<path stroke-linejoin="round" d="m12.463 24.886c2.352 1.226 22.368 5.488 33.972 5.226 16.527 0.262 30.313-6.049 32.927-7.055 0 1.433-2.307 10.273-2.614 15.679 0 5.448 1.83 28.415 2.091 33.711 0.868 6.178 2.704 13.861 4.443 19.077 1.829 3.553-23.563 9.856-34.757 10.456-12.602 0.78-38.937-4.375-37.369-8.366 0-3.968 3.659-13.383 3.659-19.599 0.522-6.025-0.262-23.273-0.262-30.836-0.261-6.78-1.053-12.561-2.09-18.293z" fill-rule="evenodd" stroke="#000000" stroke-width="1pt" fill="#fbd900"/>
	<path d="m10.633 94.659c-5.5851-1.331-7.8786 10.111-1.8288 12.021 6.3678 3.75 29.703 7.06 39.199 6.27 11.101-0.26 31.192-4.44 35.801-8.36 6.134-3.92 5.466-13.066 0-12.021-3.278 3.658-26.699 8.881-36.585 9.411-9.223 0.78-30.749-2.53-36.586-7.321z" fill-rule="evenodd" stroke="#000000" stroke-width="1pt" fill="#fbf3bf"/>
	<path stroke-linejoin="bevel" d="m77.382 34.046c1.245-3.212 9.639-6.972 12.364-7.516 4.686-1.05 12.384-1.388 16.764 4.28 7.94 10.323 6.76 28.626 2.86 34.638-2.78 5.104-9.371 10.282-14.635 11.878-5.151 1.533-12.707 2.661-14.333 3.711-0.35-1.296-1.327-7.388-1.38-9.071 1.95 0.128 7.489-0.893 11.695-1.868 3.902-0.899 6.45-3.274 9.333-6.222 5-4.7 4.35-21.16 0.54-25.057-2.233-2.262-6.849-3.904-9.915-3.323-4.992 1.032-13.677 7.366-13.677 6.98-0.508-2.08-0.25-6.159 0.384-8.43z" fill-rule="evenodd" stroke="#000000" stroke-width="1.25" fill="#fbf3bf"/>
	<path stroke-linejoin="round" d="m32.022 38.368c1.655 1.206-1.355 16.955-0.942 28.131 0.414 14.295 1.444 23.528-0.521 24.635-3.108 1.675-9.901-0.135-12.046-2.42-1.273-1.507 1.806-10.24 2.013-16.429-0.414-8.711-1.703-33.303-0.461-34.778 2.252-2.053 9.681-1.152 11.957 0.861z" fill-rule="evenodd" stroke="#000000" stroke-width="1.25" fill="#fbe600"/>
	<path d="m40.612 39.037c-1.478 1.424-0.063 19.625-0.063 22.559 0.305 3.808-1.101 27.452-0.178 28.954 1.848 2.122 10.216 2.442 13.001-0.356 1.505-1.875-0.478-22.544-0.478-27.68 0-5.51 1.407-22.052-0.44-23.58-2.033-2.149-8.44-3.18-11.842 0.103z" fill-rule="evenodd" stroke="#000000" stroke-width="1pt" fill="#fbe600"/>
	<path stroke-linejoin="round" d="m60.301 37.593c-1.658 1.256 1.179 15.8 1.194 26.982 0.137 14.299-1.245 24.662 0.824 25.709 3.268 1.578 10.881-1.542 13-3.891 1.253-1.545-1.411-10.179-2.082-16.358-0.984-8.164 0.148-33.128-1.189-34.564-2.402-1.984-9.482 0.04-11.747 2.122z" fill-rule="evenodd" stroke="#000000" stroke-width="1.25" fill="#fbe600"/>
	<path d="m53.582 31.12c-4.989 1.109-36.588-3.141-39.729-4.804 0.924 4.62 3.141 45.272 1.663 49.892 0.185 2.032-3.88 15.152-3.695 17.924 17.184-68.37 39.728-48.968 41.761-63.012z" fill-rule="evenodd" fill="url(#d)"/>
	<path d="m10.027 95.309c-3.0515-0.897-5.2053 6.821-2.872 9.151 5.743 2.69 13.282-2.33 38.23-1.61-12.743-0.36-31.589-2.874-35.358-7.541z" fill-rule="evenodd" fill="url(#c)"/>
	<path d="m78.59 33.567c4.487-4.488 8.794-5.564 13.999-6.462 8.791-2.333 14.901 3.769 16.871 11.846-4.49-7.179-10.23-8.256-14.178-8.436-4.128 0.718-15.795 7.898-16.872 9.154s-0.718-4.128 0.18-6.102z" fill-rule="evenodd" fill="url(#b)"/>
	<path stroke-linejoin="round" d="m11.408 77.34c2.3832 1.159 4.2811-1.5693 3.4649-3.0303 0.91503 0.08658 1.7948-0.3254 1.7948-1.7948 0.72044-0.72044-0.36461-1.8544-0.36461-2.7357-0.99354-0.99354 0.0056-2.165 0.0056-3.7257 0-1.5535 0.89742-2.5024 0.89742-4.1281 0-2.3611 2.0594-1.1807 0.89742-4.6666 1.0882-0.42455 2.2741-1.4845 0.89742-2.6923 2.1601-0.23952 3.2186-2.3542 0.53845-4.6666 4.0734 0-4.2302-8.7305 2.6923-6.9999 2.222-0.55551 1.7948-2.2151 1.7948-4.3076 2.8717 3.9487 6.8954 2.6213 7.5383 0 1.3486 4.3998 10.59 2.5869 10.59-2.8717 0.17948 6.7502 7.1177 3.4046 8.4358 3.9486-1.6154 1.8662 1.5841 9.0796 4.3076 9.1537-6.3097 4.7323-5.1729 13.001 2.5128 14.538 3.8938 0 5.3845-3.2785 5.3845-7.8973 1.2564 2.6447 6.972 4.2797 6.9999-0.17948 2.8717 5.5446 6.4959-1.4704 4.3076-2.1538 5.0256 1.9057 3.2128-6.9811 1.3785-9.056 2.8718-0.91448 1.8346-7.6184 0.0574-9.7898 2.6212 2.6652 6.7385-0.83112 6.282-5.923 1.228 3.4671 9.1475-0.36828 3.7692-8.4358 0-1.5451-4.4871-1.7488-5.564-0.53845-0.01541-5.4461-4.0997-9.6921-6.9999-8.6152 1.799-2.6932-9.048-4.8999-11.308-0.539 1.351-5.7012-13.81-9.3336-14.179-6.1029-1.748-2.5128-11.771-2.5586-14.718 6.2819 0-4.8606-16.309-6.9999-15.974 0.35897-3.4899-2.4331-9.2274 0.35897-8.7947 3.2307-5.3845-2.7034-7.842 9.5611-3.4102 10.231-2.5128 2.2624-2.6923 11.311 0.53845 11.128-1.9743 2.1297-0.89742 8.4366 1.2564 8.6152-1.6794 2.3206 0.2457 13.674 7.1794 11.846 0 2.5234 0.70877 4.6941-0.17948 7.3588 0 1.5455-0.89742 2.8528-0.89742 4.4871 0.37206 0.74412-1.2597 2.7244 0.53845 3.9486-4.2167 1.7593-3.3024 4.4642-1.6701 5.7226z" fill-rule="evenodd" stroke="#000000" stroke-width="1pt" fill="#ffffff"/>
	<path stroke-linejoin="round" d="m11.317 32.574c-1.5098-1.65 1.221-7.04 4.242-6.763 0.689-2.474 2.586-2.892 4.688-2.187-1.048-2.045 1.503-3.992 3.75-1.682 1.517-2.622 4.677-4.645 6.356-3.231-0.132-3.373 6.063-6.794 8.331-3.837 0 0.606-0.362 1.875 0 1.875" stroke="#000000" stroke-linecap="round" stroke-width="1pt" fill="none"/>
	<path stroke-linejoin="round" d="m48.372 22.374c-0.104-4.721 14.009-8.591 11.25-0.313 1.269-0.634 6.875-1.299 5.844 2.314 4.123-0.466 10.39 1.104 6.662 6.688 2.396 1.806 1.331 6.696-0.319 5.061" stroke="#000000" stroke-linecap="round" stroke-width="1pt" fill="none"/>
</svg>
"
    camel.apache.org/provider: "Apache Software Foundation"
    camel.apache.org/kamelet.group: "Coffees"
    camel.apache.org/kamelet.namespace: "Dataset"
  labels:
    camel.apache.org/kamelet.type: "source"
spec:
  definition:
    title: "Coffee Source"
    description: "Produces periodic events about coffees!"
    type: object
    properties:
      period:
        title: Period
        description: The time interval between two events
        type: integer
        default: 5000
  types:
    out:
      mediaType: application/json
  dependencies:
    - "camel:timer"
    - "camel:http"
    - "camel:kamelet"
  template:
    from:
      uri: "timer:coffee"
      parameters:
        period: "{{period}}"
      steps:
        - to: https://random-data-api.com/api/coffee/random_coffee
        - removeHeaders:
            pattern: '*'
        - to: "kamelet:sink"

要对其进行测试，我们可以使用简单的集成来记录其内容：

- from:
    uri: "kamelet:coffee-source?period=5000"
    steps:
      - log: "${body}"

现在，我们可以运行：

$ camel run --local-kamelet-dir=</path/to/local/kamelets/dir> coffee-integration.yaml
2022-11-24 11:27:29.634  INFO 39527 --- [           main] org.apache.camel.main.MainSupport        : Apache Camel (JBang) 3.18.1 is starting
2022-11-24 11:27:29.706  INFO 39527 --- [           main] org.apache.camel.main.MainSupport        : Using Java 11.0.17 with PID 39527. Started by squake in /home/squake/workspace/jbang/camel-blog
2022-11-24 11:27:31.391  INFO 39527 --- [           main] e.camel.impl.engine.AbstractCamelContext : Apache Camel 3.18.1 (CamelJBang) is starting
2022-11-24 11:27:31.590  INFO 39527 --- [           main] org.apache.camel.main.BaseMainSupport    : Property-placeholders summary
2022-11-24 11:27:31.590  INFO 39527 --- [           main] org.apache.camel.main.BaseMainSupport    :     [coffee-source.kamelet.yaml]     period=5000
2022-11-24 11:27:31.590  INFO 39527 --- [           main] org.apache.camel.main.BaseMainSupport    :     [coffee-source.kamelet.yaml]     templateId=coffee-source
2022-11-24 11:27:31.591  INFO 39527 --- [           main] e.camel.impl.engine.AbstractCamelContext : Routes startup (started:2)
2022-11-24 11:27:31.591  INFO 39527 --- [           main] e.camel.impl.engine.AbstractCamelContext :     Started route1 (kamelet://coffee-source)
2022-11-24 11:27:31.591  INFO 39527 --- [           main] e.camel.impl.engine.AbstractCamelContext :     Started coffee-source-1 (timer://coffee)
2022-11-24 11:27:31.591  INFO 39527 --- [           main] e.camel.impl.engine.AbstractCamelContext : Apache Camel 3.18.1 (CamelJBang) started in 1s143ms (build:125ms init:819ms start:199ms JVM-uptime:2s)
2022-11-24 11:27:33.297  INFO 39527 --- [ - timer://coffee] coffee-integration.yaml:4                  : {"id":3648,"uid":"712d4f54-3314-4129-844e-9915002ecbb7","blend_name":"Winter Cowboy","origin":"Lekempti, Ethiopia","variety":"Agaro","notes":"delicate, juicy, sundried tomato, fresh bread, lemonade","intensifier":"juicy"}

这是在编程 Kamelet 时的提升，因为您可以快速反馈而无需集群。准备就绪后，您可以继续将 Kamelet 上传到集群并使用 Camel K 集成。

YAKS 是一个开源测试自动化平台，它利用行为驱动开发概念在本地和云基础架构上运行测试（例如： Kubernetes 或 OpenShift）。这意味着测试工具能够将您的测试作为本地测试运行，并在 Kubernetes 上原生运行。该框架专为验证 Serverless 和 microservice 应用程序而设计，旨在集成测试下测试并在类似于生产环境的环境中运行的应用程序。典型的 YAKS 测试使用与不同消息传递传输过程中的应用相同的基础架构（例如：Http REST、Knative 事件、Kafka、JMS 等）。

因为 YAKS 本身以 Java 编写，运行时将使用 Java 虚拟机以及 Maven 等构建工具，并与 JUnit、Cucumber 和 Citrus 等已知 Java 测试框架集成来运行测试。

以下是我们想要测试的 Camel K 集成示例：该集成会向用户公开 Http 服务。该服务接受添加 fruit 模型对象的客户端 Http POST 请求。Camel K 路由应用基于内容的路由，将有问题的路由存储在不同的 AWS S3 存储桶中。

在测试场景中，YAKS 将调用 Camel K 服务，并验证消息内容是否已发送到正确的 AWS S3 存储桶。

以下是可能存储在 AWS S3 中的模糊模型对象示例：

{
  "id": 1000,
  "name": "Pineapple",
  "category":{
    "id": "1",
    "name":"tropical"
  },
  "nutrition":{
    "calories": 50,
    "sugar": 9
  },
  "status": "AVAILABLE",
  "price": 1.59,
  "tags": ["sweet"]
}

以下是 Camel K 集成路由：

from('platform-http:/fruits')
    .log('received fruit ${body}')
    .unmarshal().json()
    .removeHeaders("*")
    .setHeader("CamelAwsS3Key", constant("fruit.json"))
    .choice()
        .when().simple('${body[nutrition][sugar]} <= 5')
            .setHeader("CamelAwsS3BucketName", constant("low-sugar"))
        .when().simple('${body[nutrition][sugar]} > 5 && ${body[nutrition][sugar]} <= 10')
            .setHeader("CamelAwsS3BucketName", constant("medium-sugar"))
        .otherwise()
            .setHeader("CamelAwsS3BucketName", constant("high-sugar"))
    .end()
    .marshal().json()
    .log('sending ${body}')
    .to("aws2-s3://noop?$parameters")

路由使用基于内容的路由 EAP，基于给定模糊的 nutrition sugar 评级，将模糊应用到不同的 AWS S3 存储桶(low-sugar, medium-sugar, high-sugar)。

在进行此集成的测试案例中，需要使用不同的模糊调用公开的服务并验证其在 AWS S3 上的结果。

开始时，让我们只编写测试并在本地运行它。现在，我们不关心如何在云基础架构中进行测试，因为所有内容在使用 JBang 的计算机上运行。

JBang 是仅开始编码和运行 Java 代码以及 Camel K 集成（也看到此前文中关于 JBang 与 Camel K 集成）的好方法。

YAKS 作为框架提供了一组现成的域特定语言(XML、YAML、Groovy、BDD Cucumber 步骤)，用于编写测试以验证部署的服务。

此后，通过 Cucumber 使用行为驱动开发集成。因此，YAKS 测试是使用 BDD Gherkin 语法的单一功能文件，如下所示：

Feature: Camel K Fruit Store

  Background:
    Given URL: http://localhost:8080

  Scenario: Create infrastructure
    # Start AWS S3 container
    Given Enable service S3
    Given start LocalStack container

    # Create Camel K integration
    Given Camel K integration property file aws-s3-credentials.properties
    When load Camel K integration fruit-service.groovy
    Then Camel K integration fruit-service should print Started route1 (platform-http:///fruits)

  Scenario: Verify fruit service
    # Invoke Camel K service
    Given HTTP request body: yaks:readFile('pineapple.json')
    And HTTP request header Content-Type="application/json"
    When send POST /fruits
    Then receive HTTP 200 OK

    # Verify uploaded S3 file
    Given New global Camel context
    Given load to Camel registry amazonS3Client.groovy
    Given Camel exchange message header CamelAwsS3Key="fruit.json"
    Given receive Camel exchange from("aws2-s3://medium-sugar?amazonS3Client=#amazonS3Client&deleteAfterRead=true") with body: yaks:readFile('pineapple.json')

逐步浏览测试步骤。首先，功能文件使用常见的 Given-When-Then BDD 语法来给出上下文，描述操作并验证结果。每个步骤都调用框架开箱即用的特定 YAKS 操作。用户可以从 大量的步骤 中选择，它们会自动执行诸如发送/接收 Http 请求/响应、启动 Testcontainers、运行 Camel 路由、连接到数据库、在 Kafka 或 Knative 代理上的事件等操作。

在第一个场景中，测试会自动准备一些所需的基础架构。YAKS 测试启动 Localstack Testcontainer 来运行 AWS S3 测试实例(Given start LocalStack 容器)。然后，测试会加载并启动 Camel K integration in test (当加载 Camel K integration fruit-service.groovy)，并等待它正确启动。本地测试中，此步骤使用 JBang 启动 Camel K 集成。之后，后期还会在 Kubernetes 环境中运行测试。

现在，基础架构已启动并运行，测试能够加载 fruit 模型对象作为 Http 请求正文(Given HTTP request body: yaks:readFile ('pineapple.json'))，并调用 Camel K 服务(发送 POST /fruits)。该测试会等待 Http 响应，并验证其 200 OK 状态。

在最后一步中，测试会验证 fruit 对象是否已添加到正确的 AWS S3 存储桶(medium-sugar)。因为 YAKS 本身无法连接到 AWS S3，因此测试将 Apache Camel 用于这一步。该测试会创建一个 Camel 上下文，加载 AWS 客户端，并使用临时 Camel 路由连接到 AWS S3 (Given 接收 Camel 交换来自("aws2-s3://medium-sugar?amazonS3Client=45amazonS3Client&deleteAfterRead=true"))。使用这个 Apache Camel 集成 YAKS，可以使用完整的 300+ Camel 组件来发送和接收信息到各种消息传递传输。Camel Exchange body 必须是与初始 Http 请求中发布的相同模糊模型对象（yaks:readFile ('pineapple.json')。

YAKS 使用 Citrus 提供的强大的消息有效负载验证功能进行此消息内容验证。验证能够比较类型为 XML、Json、纯文本等消息内容。

该操作将完成测试案例。现在，您可以使用 Cucumber 和 JUnit 实例运行此测试。直接使用 YAKS 运行测试的最简单方法是使用 YAKS 命令行客户端。您不需要使用 Maven 依赖项设置整个项目，等等。只需编写测试文件并使用以下方法运行：

$ yaks run fruit-service.feature --local

您应该看到一些日志输出，如下所示：

INFO |
INFO | ------------------------------------------------------------------------
INFO |        .__  __
INFO |   ____ |__|/  |________ __ __  ______
INFO | _/ ___\|  \   __\_  __ \  |  \/  ___/
INFO | \  \___|  ||  |  |  | \/  |  /\___ \
INFO |  \___  >__||__|  |__|  |____//____  >
INFO |      \/                           \/
INFO |
INFO | C I T R U S  T E S T S  3.4.0
INFO |
INFO | ------------------------------------------------------------------------
INFO |

Scenario: Create infrastructure # fruit-service.feature:6
  Given URL: http://localhost:8080
  Given Enable service S3
  [...]

Scenario: Verify fruit service # fruit-service.feature:20
  Given URL: http://localhost:8080
  Given HTTP request body: yaks:readFile('pineapple.json')
  [...]

Scenario: Remove infrastructure  # fruit-service.feature:31
  Given URL: http://localhost:8080
  Given delete Camel K integration fruit-service
  Given stop LocalStack container

3 Scenarios (3 passed)
18 Steps (18 passed)
0m18,051s


INFO | ------------------------------------------------------------------------
INFO |
INFO | CITRUS TEST RESULTS
INFO |
INFO |  Create infrastructure .......................................... SUCCESS
INFO |  Verify fruit service ........................................... SUCCESS
INFO |  Remove infrastructure .......................................... SUCCESS
INFO |
INFO | TOTAL: 3
INFO | FAILED: 0 (0.0%)
INFO | SUCCESS:    3 (100.0%)
INFO |
INFO | ------------------------------------------------------------------------

3 Scenarios (3 passed)
18 Steps (18 passed)
0m18,051s


Test results: Total: 0, Passed: 1, Failed: 0, Errors: 0, Skipped: 0
    fruit-service (fruit-service.feature): Passed

YAKS 能够在本地和 Kubernetes 集群一部分运行测试。在 Cloud infrastructure YAKS 上运行测试时，利用 Operator SDK 并提供一个特定的 operator 来管理集群中的测试问题单资源。每次以 自定义资源 的形式声明测试时，YAKS 操作器会自动处理准备正确的运行时，以便将测试作为 Kubernetes Pod 执行。

使用 Camel K 为实例编写 Serverless 或 microservices 应用程序非常声明性。作为您刚刚编写 Camel 路由的开发者，并通过 Camel K operator 直接在集群中运行它。Serverless 应用程序的声明方法以及 Serverless 应用程序的性质使得我们依赖于给定的运行时基础架构，对于验证该基础架构上的应用程序也至关重要。因此，只有将验证测试移到这种非常相同的云基础架构中才会自然。这就是为什么 YAKS 也将测试引入云基础架构，以进行集成和端到端测试。

下面是它的运作方式。您可以运行与 Kubernetes 中本地运行的相同 YAKS 测试。

YAKS 提供 Kubernetes operator 和一组需要安装到的 CRD （自定义资源）。安装 YAKS 的最佳方法是使用 OperatorHub 或 yaks CLI 工具，您可以从 YAKS GitHub 发行页 下载。

使用 yaks-client 二进制文件只运行这个 install 命令：

$ yaks install

此命令会准备您的 Kubernetes 集群，以使用 YAKS 运行测试。它将负责安装 YAKS 自定义资源定义，设置角色权限并在全局 operator 命名空间中创建 YAKS Operator。

现在，YAKS 操作器已经启动并在运行，您可以在云基础架构上从本地测试运行相同的测试。需要完成的唯一操作是将 Camel K 集成的 Http 端点 URL 从 http://localhost:8080 调整为 http://fruit-service.${YAKS_NAMESPACE}

$ yaks run fruit-service.feature

YAKS CLI 连接到 Kubernetes 集群，而不是使用本地 JBang 工具在本地运行测试，以作为自定义资源创建测试。从 中，YAKS 操作器负责准备测试运行时并将测试作为 Pod 运行。

测试已准备一些基础架构，特别是 Camel K 集成和 AWS S3 Localstack Testcontainer 实例。这如何在 Kubernetes 内工作？YAKS 完全负责它。Camel K 集成与在同一 Kubernetes 集群上运行的 Camel K operator 运行。然后 Testcontainer AWS S3 实例会在 Kubernetes 中自动作为 Pod 运行。即使连接设置也会自动处理。它只是工作！

远程运行测试时，您将看到一些类似的测试日志输出，测试将执行其操作及其验证与本地的完全相同。

您还可以使用以下方法查看测试 Pod 结果：

$ yaks ls

这是一个输出示例，您应该获得：

NAME           PHASE   TOTAL  PASSED  FAILED  SKIPPED  ERRORS
fruit-service  Passed  3      3       0       0        0

此 GitHub 存储库 上提供了整个演示代码。它还介绍了如何在 GitHub CI 操作工作流中集成测试，以便您可以使用每个代码更改自动运行测试。

Apache Camel K 是由 Apache Camel 构建的轻量级集成框架，可在 Kubernetes 上原生运行，专为无服务器和微服务架构而设计。

Camel K 用户可以在首选云(Kubernetes 或 OpenShift)上立即运行使用 Camel DSL 编写的集成代码。

如果测试中的主题是 Camel K 集成，您可以利用 YAKS Camel K 绑定来提供 Camel K 集成的有效步骤。

使用 Camel K 集成

Given create Camel K integration helloworld.groovy
"""
from('timer:tick?period=1000')
  .setBody().constant('Hello world from Camel K!')
  .to('log:info')
"""
Given Camel K integration helloworld is running
Then Camel K integration helloworld should print Hello world from Camel K!

YAKS 框架默认提供 Camel K 扩展库。您可以创建新的 Camel K 集成并检查集成的状态（例如，运行）。

以下小节详细介绍了可用的 Camel K 步骤。

YAKS_CAMELK_API_VERSION=v1alpha1

Given create Camel K integration {name}.groovy
"""
<<Camel DSL>>
"""

Given create Camel K integration {name}.groovy with configuration:
  | dependencies | mvn:org.foo:foo:1.0,mvn:org.bar:bar:0.9 |
  | traits       | quarkus.native=true,quarkus.enabled=true,route.enabled=true |
  | properties   | foo.key=value,bar.key=value |
  | source       | <<Camel DSL>> |

Given load Camel K integration {name}.groovy

Given delete Camel K integration {name}

Given Camel K integration {name} is running

Given Camel K resource polling configuration
    | maxAttempts          | 10   |
    | delayBetweenAttempts | 1000 |

Given Camel K integration {name} should print {log-message}

Given Camel K resource polling configuration
    | maxAttempts          | 10   |
    | delayBetweenAttempts | 1000 |

Given Camel K integration {name} should not print {log-message}

Given Disable auto removal of Camel K resources

Given Enable auto removal of Camel K resources

kamelets 是 Camel K 中实施的预定义 Camel 路由模板的形式。通常是一个 Kamelet 封装某个功能（例如，发送消息到端点）。Additionaly Kamelets 定义一组用户在使用 Kamelet 时提供的属性。

YAKS 提供管理 Kamelets 的步骤。

YAKS_KAMELET_API_VERSION=v1

Given Kamelet dataType in="{mediaType}"

Given Kamelet title "{title}"

Given Kamelet template
"""
from:
  uri: timer:tick
  parameters:
    period: "#property:period"
  steps:
  - set-body:
      constant: "{{message}}"
  - to: "kamelet:sink"
"""

Given Kamelet property definition message
  | type     | string        |
  | required | true          |
  | example  | "hello world" |
  | default  | "hello"       |

Given Kamelet source timer.yaml
"""
<<YAML>>
"""

Given create Kamelet {name}

Given create Kamelet {name} with template
"""
<<YAML>>
"""

Given load Kamelet {name}.kamelet.yaml

Given delete Kamelet {name}

Given Kamelet {name} is available$

您可以将 Kamelet 绑定到 sink。这个概念在管道中进行了描述。YAKS 作为框架能够与 Kamelets 结合使用创建和验证 Pipes。

Given bind Kamelet {name} to uri {uri}

Given bind Kamelet {kamelet} to Kafka topic {topic}

Given bind Kamelet {kamelet} to Knative channel {channel}

Given bind Kamelet {kamelet} to Knative channel {channel} of kind {kind}

Given Pipe source properties
  | {property}  | {value} |

Given Pipe source properties
  | message  | "Hello world" |

Given Pipe sink properties
  | {property}  | {value} |

Given create Pipe {name}

Given load Pipe {name}.yaml

Given delete Pipe {name}

Given Pipe {name} is available$

Given Disable auto removal of Kamelet resources

Given Enable auto removal of Kamelet resources