Question

我正在寻找BDD java框架，可以重用Given＆amp;然后进行单元和集成测试。

换句话说 1. 给出一些先决条件。 2. 何时 - 取决于环境 3. 然后验证何时

的结果

我希望能够通过更改When，并保持给定和然后完整，更改测试类型，例如在简单的REST服务中：

UNIT测试
- 的鉴于
  - 生成一些POJO对象
- ：当
  - 从给定
  - 使用此POJO调用内部服务
  - 从服务
  - 前锋收到POJO至然后
- ，然后
  - 从何时
整合测试
- 的鉴于
  - 生成一些POJO对象
- ：当
  - 从给定
  - 以外部服务格式加密POJO
  - 调用外部服务
  - 从公开服务
  - 转换收到的结果在POJO
  - 前锋收到POJO至然后
- ，然后
  - 从何时

所以在示例中，对于集成和单元测试，给定和然后的行为方式相同，并且只需更改当测试的范围变为从UNIT到INTEGRATION 。

有人能指出我正确的方向吗？

我不想重新发明轮子

Answer 1

Disclamer：我是JGiven的作者。

JGiven完全提供了这一点。它是Java的BDD框架，其中场景由所谓的阶段类构建。对于您的示例，您需要四个阶段类：GivenInput，WhenInternalService，WhenExternalService和ThenOutput。然后你可以编写两个测试：

内部服务的单元测试：

public class InternalServiceTest extends 
       ScenarioTest<GivenInput, WhenInternalService, ThenOutput> {

    @Test
    public void internal_service_works_as_expected() {
       given().some_input();
       when().the_internal_service_is_called();
       then().the_result_is_correct();
    } 
}

外部服务的集成测试：

public class ExternalServiceTest extends 
       ScenarioTest<GivenInput, WhenExternalService, ThenOutput> {

    @Test
    public void external_service_works_as_expected() {
       given().some_input();
       when().the_external_service_is_called();
       then().the_result_is_correct();
    } 
}

舞台课程看起来像这样：

public class GivenInput extends Stage<GivenInput> {
    @ProvidedScenarioState
    InputPojo input;

    public GivenInput some_input() {
       input = new InputPojo();
       return self();
    }
}

public class WhenInternalService extends Stage<WhenInternalService> {
    @ExpectedScenarioState
    InputPojo input;

    @ProvidedScenarioState
    OutputPojo output;

    public WhenInternalService the_internal_service_is_called() {
        output = new InternalService().invoke(input);
        return self();
    }
}

public class WhenExternalService extends Stage<WhenExternalService> {
    @ExpectedScenarioState
    InputPojo input;

    @ProvidedScenarioState
    OutputPojo output;

    public WhenExternalService the_external_service_is_called() {
        ExternalInput externalInput = transformToExternal(input);
        ExternalOutput externalOutput = new ExternalService().invoke(external);
        output = transformToInternal(externalOutput);
        return self();
    }
}

public class ThenOutput extends Stage<ThenOutput> {
    @ExpectedScenarioState
    OutputPojo output;

    public ThenOutput the_result_is_correct() {
        assertThat(output).isNotNull();
        return self();
    }
}

请注意，步骤方法以流畅的界面风格编写，以便能够链接多个条件（尽管在您的示例中不需要）。

Answer 2

如果您使用的是Java 8，那么您应该查看this github项目。

使用它可以实现您想要的而无需创建类的麻烦。这是因为使用了Generics + Java 8 Lambdas。

以下是一些基本测试样本：

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

Answer 3

的JUnit？

很可能有一个带有@Before方法的抽象基类（即“Given”）和一个带断言的常用方法（即“Then”）。

是否有BDD java框架能够重用Given，那么？（随着步骤变化）

3 个答案:

是否有BDD java框架能够重用Given，那么？ （随着步骤变化）

3 个答案:

是否有BDD java框架能够重用Given，那么？（随着步骤变化）