是否有BDD java框架能够重用Given,那么？(随着步骤变化)

Question

我正在寻找可以重用Given&Then for Unit和Integration测试的BDD java框架.

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

我希望能够通过更改When,并保持Given和Then完整,更改测试的类型,例如在简单的REST服务中:

1. 单元测试
   • 特定
     • 生成一些POJO对象
   • 什么时候
     • 收到来自Given的 POJO
     • 使用此POJO调用内部服务
     • 从服务接收POJO表单的结果
     • 前锋收到了POJO 然后
   • 然后
     • 从When验证POJO
2. 整合测试
   • 特定
     • 生成一些POJO对象
   • 什么时候
     • 收到来自Given的 POJO
     • 以外部服务格式加密POJO
     • 呼叫外部服务
     • 从公开的服务接收外部服务格式的结果
     • 在POJO中转换收到的结果
     • 前锋收到了POJO 然后
   • 然后
     • 从When验证POJO

因此,在示例中,Given和Then的行为方式相同,对于集成和单元测试,以及简单地改变当测试的范围从UNIT到INTEGRATION时.

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

我不想重新发明轮子

Answer 1

免责声明:我是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，那么您应该看看这个github 项目。

使用这个你可以实现你想要的，而无需创建类的麻烦。这是由于使用了泛型 + Java 8 Lambda。

以下是一些基本测试示例：

@Test
public void basicFlowTest() {
 given(1)
  .when("multiplying by 2", givenValue -> 2 * givenValue)
  .then("value should be even", whenValue -> whenValue % 2 == 0);
}

public void multiTypeFlowTest() {
 LocalDateTime localDateTime = LocalDateTime.now();
 DayOfWeek expectedDay = localDateTime.getDayOfWeek();

 given(localDateTime)
  .when("retrieving current day", date -> date.getDayOfWeek())
  .then("days should match", day -> expectedDay == day);
}

@Test
public void assertFlowTest() {
 Integer primeNumber = 17;
 given("a prime number", primeNumber)
  .when("finding dividers naively", number -> IntStream.rangeClosed(1, number)
   .boxed().filter(value -> number % value == 0).collect(Collectors.toList()))
  .then(dividers -> {
   assertEquals("should have two dividers", 2, dividers.size());
   assertEquals("first divider should be 1", 1, (int) dividers.get(0));
   assertEquals(String.format("first divider should be %d", primeNumber), primeNumber, dividers.get(1));
  });
}